Python is a popular programming language with a variety of built-in functions designed to make coding easy and efficient. Among these built-in functions is the `sum()`

method, which allows for easy addition of values in an iterable object.

In this article, we will explore the `sum()`

method and how to use it for different iterables.

## Python `sum()`

method

The `sum()`

method in Python returns the sum of all the values found in an iterable object. The iterable object can be any sequence that has a collection of values, such as a list, tuple, or a dictionary.

## Syntax of `sum()`

method

The syntax of the `sum()`

method is simple and straightforward. The method takes only one parameter, which is the iterable object that you want to sum the values of.

### The syntax can be written as:

`sum(iterable, start=0)`

The `iterable`

is the object whose values are to be added, whereas `start`

is the value to start the summing with. The `start`

parameter is optional, and if you don’t specify it, the summing starts from zero.

## Using `sum()`

for different iterables

### Summing values of a list, tuple, dictionary, and complex numbers

Python’s `sum()`

method can be used to add values from a variety of iterables. Objects like lists, tuples, and dictionaries can be summed using the method.

When working with a list or tuple, the following syntax is used:

```
my_list = [6, 7, 8, 9, 10]
my_sum = sum(my_list)
print(my_sum) # Output: 40
```

When working with a dictionary, the `sum()`

method will automatically sum the keys in the dictionary rather than the values of the keys. To sum the values, you must specify the `values()`

method.

```
my_dict = {'a':1, 'b':2, 'c':3}
my_sum = sum(my_dict.values())
print(my_sum) # Output: 6
```

The `sum()`

method can also be used to sum the values of complex numbers. Here is an example:

```
my_complex_list = [2+3j, 4-6j, 6-1j]
my_sum = sum(my_complex_list)
print(my_sum) # Output: (12-4j)
```

## Error if iterable is empty

If the iterable passed in as a parameter to the `sum()`

method is empty, then the function will raise an error. It is, therefore, essential to check that the iterable is not empty before calling the `sum()`

method.

### Here is an example of how to handle this error:

```
my_list = []
my_sum = sum(my_list, start=0)
if not my_sum:
print("The list is empty.")
```

In conclusion, the `sum()`

method in Python is an efficient way to add values in iterable objects such as lists, tuples, and dictionaries. It allows for easy calculation of the sum of all values in an iterable and can save time when working with large sets of data.

However, it is essential to check that the iterable is not empty before using the `sum()`

method to avoid errors. By following the syntax of `sum()`

and the examples provided, you will be able to use the `sum()`

method effectively in your Python programs.

## Comparison of `sum()`

and `np.sum()`

methods

Python `sum()`

and NumPy `sum()`

are two methods in Python that can be used to calculate the sum of values in an iterable. In this section, we will explore the differences between these two methods.

The `sum()`

method in Python is a built-in function that can be used to add the values of an iterable. The `np.sum()`

method is a function in the NumPy library, which performs the same task of adding the values of an iterable.

While both methods can be used for summing values, there are some differences between them. The `np.sum()`

method is more efficient than the `sum()`

method for larger arrays because it is implemented in C, which is faster than the Python interpreter.

### Using `sum()`

and `np.sum()`

on lists and numpy arrays

The `sum()`

method can be used to add values in lists. Here is an example of how to use `sum()`

on a list:

```
my_list = [1, 2, 3, 4, 5]
my_sum = sum(my_list)
print(my_sum)
```

### The output for the code is:

`15`

The `np.sum()`

method can be used to add values in numpy arrays. Here is an example of how to use `np.sum()`

on a numpy array:

```
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
my_sum = np.sum(my_array)
print(my_sum)
```

### The output for the code is:

`15`

As you can see from the example above, both the `sum()`

method and `np.sum()`

method can be used to calculate the sum of values in a list or a numpy array. However, when dealing with large data sets, the `np.sum()`

method is more efficient than the `sum()`

method.

### Here is an example of how to time both methods on a large array:

```
import numpy as np
import time
my_array = np.ones(1000000)
start_time = time.time()
np_sum = np.sum(my_array)
print("NumPy sum(): %f seconds" % (time.time() - start_time))
start_time = time.time()
py_sum = sum(my_array)
print("Python sum(): %f seconds" % (time.time() - start_time))
```

### The output for the code is:

```
NumPy sum(): 0.000031 seconds
Python sum(): 0.172443 seconds
```

As you can see from the example above, the `np.sum()`

method is orders of magnitude faster than the `sum()`

method. In conclusion, both the `sum()`

method and `np.sum()`

method can be used to add values in lists or numpy arrays.

However, when working with larger data sets, the `np.sum()`

method is more efficient than the `sum()`

method because it is implemented in C. It is essential to consider the size of your data set when choosing between the two methods for the most efficient calculation of the sum.

In conclusion, the `sum()`

method and `np.sum()`

method in Python are both useful tools for calculating the sum of values in iterables such as lists or numpy arrays. While the `sum()`

method is a built-in Python function, the `np.sum()`

method is a function in the NumPy library.

The primary difference between the two methods is that the `np.sum()`

method is more efficient than the `sum()`

method when dealing with larger data sets. Therefore, it is essential to choose the right method depending on the size of your data set for optimal performance.

By following the syntax and examples provided in this article, you can efficiently use these methods to sum values in your Python programs and projects.