Introduction
Functions in Python are some of the core elements of the language for the purposes of code reuse, code modularity, and code abstraction. Functions basically contain logic, and therefore, when they are implemented, they help in coming up with better programs that are easier to test, correct, or even maintain.
Functions provide a way of dividing big tasks into small sub-tasks so that they can be executed effortlessly, and performing the same task more than once is easy.
Extensibility is also effective in that the Python programming language has plenty of inbuilt procedures, and one can also create his/her own procedures in order to enhance the functioning of several programming challenges.
Top 10 Python Functions
Today, in this article, we are going to understand the 10 Python functions that you should incorporate in your programming practice, especially when faced with data structure challenges.
These functions will reduce the bulkiness of your code while enabling you to solve complicated problems and increase your programming efficiency.
1. map() function
In Python, map() is a convenient function used to apply a specific function to each element of an iterable (such as a list or tuple) and return the resulting output as a map object.
This allows you to perform bulk processing with less code. For example, if you have a list of numbers and you want to square each number, the map function can do this efficiently.
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x**2, numbers)
print(list(squared_numbers))
# Output: [1, 4, 9, 16, 25]The syntax for map() is simple, map(function, iterable). A map object is related to the iterable and represents an item from the output of the function parameter applied individually to each sequence item.
To convert it to a list or tuple, you can simply cast the map object using list() or tuple(). Here’s a quick example of how to use map() to convert a list of strings to uppercase.
words = ['hello', 'world', 'python']
upper_words = map(str.upper, words)
print(list(upper_words))
# Output: ['HELLO', 'WORLD', 'PYTHON']2. filter() function
In Python, the filter() function filters elements based on a function that returns True or False. Which makes easy filtering out things that meet some conditions.
Take the example of an array that includes numbers and you only want to return those that are even; here filter() is a shoulder-less way to offer a clean solution.
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))
# Output: [2, 4, 6]The syntax for filter() is, filter(function, iterable). This creates a filter object, which includes elements from the iterable that satisfy the condition defined in the function. You can convert the filter object into a list or tuple to view the filtered results.
Here’s an example of filtering out words shorter than five characters.
words = ['apple', 'banana', 'kiwi', 'cherry']
long_words = filter(lambda word: len(word) >= 5, words)
print(list(long_words))
# Output: ['apple', 'banana', 'cherry']3. reduce() function
The reduce() function available in the functools module is used to perform a cumulative operation on an iterable and return just one single output.
The function is used to apply the given specific operation to an item in an iterable; it calculates and stores its result.
The code below computes the product of all the numbers in a list using the reduce() function.
from functools import reduce
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print(product)
# Output: 24reduce() is most useful when you need to combine parts of an iterable into a single result. It yields concise and readable code by eliminating explicit loops and intermediate variables.
For example, The code below finds the maximum value in a list using the reduce() function.
from functools import reduce
numbers = [1, 2, 3, 4]
max_value = reduce(lambda x, y: x if x > y else y, numbers)
print(max_value)
# Output: 44. zip() function
The zip() function returns a new iterable (e.g., list, tuple) consisting of tuples created from the elements in corresponding positions from each of its arguments.
It is mostly important for the case in which you want to make pairs of different items from two or more sequences.
For instance, you might have two lists, one that holds names and the other ages, zip() will then group all n-th element in every list together.
names = ['Alice', 'Bob', 'Charlie']
ages = [24, 30, 18]
paired = zip(names, ages)
print(list(paired))
# Output: [('Alice', 24), ('Bob', 30), ('Charlie', 18)]zip() can take more than two iterables, form tuples that consists of elements at the same index from each. When the iterables are of different lengths, zip() stops producing tuples once the shortest iterable is exhausted.
The following is an example which joins three lists into tuples.
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 90, 78, 100]
grades = ['B', 'A', 'C', 'D']
combined = zip(names, scores, grades)
print(list(combined))
# Output: [('Alice', 85, 'B'), ('Bob', 90, 'A'), ('Charlie', 78, 'C')]5. enumerate() function
In Python, the enumerate() function is a built-in method used to iterate through an associated iterable with index. It sets up an automatic running iterator and returns (index, value) tuples.
To give an example, if there is a list of items and you would like to print each item and its index, enumerate() gives us the clean approach.
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
# Output:
# Index 0: apple
# Index 1: banana
# Index 2: cherryAdditionally, you can customize where the index starts by providing a starting value as the second argument to enumerate().
By default, it starts counting from 0, but you can make it start from any number you choose, like 1. This is useful if you prefer your counts to start from 1 instead of 0, which can be more intuitive in some cases.
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start=1):
print(f"Index {index}: {fruit}")
# Output:
# Index 1: apple
# Index 2: banana
# Index 3: cherry
6. sorted() function
The function sorted() in Python helps in returning a new list. This list contains all items from iterable in increasing order. Unlike the sort() method, which sorts the list in place, sorted() creates a new list that’s sorted, leaving the original iterable stays unchanged.
numbers = [5, 3, 9, 1, 7]
sorted_numbers = sorted(numbers)
print(sorted_numbers)
# Output: [1, 3, 5, 7, 9]sorted() offers a chance to give custom criteria for sorting. This is through a key parameter. This parameter is the key. It accepts function. This function returns a value. This value is used for sorting purposes.
The example below demonstrates how to sort a list of strings based on the length of each string.
words = ['apple', 'banana', 'cherry', 'date']
sorted_by_length = sorted(words, key=len)
print(sorted_by_length)
# Output: ['date', 'apple', 'banana', 'cherry']7. all() function
In Python, the all() function is handy for checking if every item in a list or other iterable meets a certain condition. It returns True if all the elements are true (or if the iterable is empty), and False if any element is false.
This is especially useful when you want to make sure all items in a collection satisfy specific criteria. For instance, you might use all() to check if every number in a list is positive.
numbers = [1, 2, 3, 4, 5]
all_positive = all(n > 0 for n in numbers)
print(all_positive)
# Output: TrueIf you’re working with an empty iterable, all() will also return True because there are no items that can contradict the condition.
This makes it easier to handle edge cases in your code. Here’s a simple example of how all() behaves with an empty list.
empty_list = []
result = all(empty_list)
print(result)
# Output: True8. any() function
The any() function in Python is really handy when you need to find out if there’s at least one item in a list (or any other collection) that’s true. It’ll give you True if at least one item is true, and False if everything is false or if the collection is empty.
For example, you could use any() to find out if there’s at least one positive number in your list.
numbers = [0, -1, 2, -3]
has_positive = any(n > 0 for n in numbers)
print(has_positive)
# Output: TrueJust like all(), any() will give you False when it’s used on an empty collection since there are no items to evaluate. It’s good to keep this in mind when working with data that might change or when checking multiple conditions.
Here’s a simple example of how any() works with an empty list.
empty_list = []
result = any(empty_list)
print(result)
# Output: False9. sum() function
Let’s talk about the sum() function in Python. It’s a really useful for adding up all the numbers in a list or any collection.
If you’ve got a bunch of numbers and need to get their total, sum() does it quickly and effortlessly.
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)
# Output: 15And here’s a neat trick, sum() also lets you start with a specific number if you need to. This is super useful if you want to add an initial value before summing up your list.
numbers = [1, 2, 3, 4]
total_with_start = sum(numbers, 10)
print(total_with_start)
# Output: 2010. open() function
The open() method in Python allows you to open files and returns a file object which provides the methods used to read, write and manipulate the content of the file.
You have the choice to indicate the type of operation to be performed on the file by specifying the opening and mode of the file for instance it can be reading (‘r’), writing (‘w’) or appending (‘a’).
For instance if one intends to read a certain file all that should happen is the following code.
with open('example.txt', 'r') as file:
content = file.read()
print(content)
# No need to explicitly call file.close(), it's handled automaticallyConclusion
Thanks to these functions, you will be able to accomplish numerous tasks more realistically, whether it relates to data processing or performing operations of a complex nature, file handling, or collection analysis.
Applying these functions in other activities leaves you with well-structured and focused code. Doing such operations on the code can be time-consuming; however, it is worth it as the abstractions are useful in less frequently performed or more complicated tasks, simplifying normal activities on the code.
While an application utilizes data storage, queries, computations, and data manipulations, and file or data handling, there are in-built procedures in Python that facilitate heightened programming activities and effective task achievement.
