Python is one of the most lucrative programming languages. According to research, there were approximately 10 million Python developers in 2020 worldwide and the count is increasing day by day. It provides ease in building a plethora of applications, web development processes, and a lot more. When it comes to making a program short and clear, we use in-built functions which are a set of statements collectively performing a task. Using in-built functions in a program makes it beneficial in many ways such as:
- Makes it less complex.
- Enhances readability.
- Reduces coding time and debugging time.
- Allows re-usage of code.
Hence, it plays a major role in the development of an application. In python 3, we have 68 in-built functions, some of them are listed below:
1) append()
This method adds an item at the end of the existing list, tuple, or any other set. Then, the length of the list gets increased by one. We can append an item to the list and also list to a list. It adds any data type which is to be added at the end of the list. It has time complexity: O(1).
Syntax:
append(item)
where item refers to the item needed to be appended with the existing element.
For Example:
a=[“apple”,” banana”,” mango”,” grapes”]
a.append(“orange”)
print(a)
Output:
[“apple”,” banana”,” mango”,” grapes”,” orange”]
2) reduce()
The reduce() function applies a function of two arguments collectively on a list of objects in succession from left to right to reduce it to one value. It is defined in a functools library. This works better than for loop.
Syntax:
reduce(function, iterable)
where, function refers to the function which will be used in a program, and iterable refers to the value that will be iterated in the program.
For Example:
From functools import reduce
Def sum(a, b):
res=return (sum, [1,2,4,5])
print res
Output:
12
3) slice()
This function returns the sliced object from a given set of elements. It allows you to access any set of sequences whether it is ta tuple, list, or set. Time complexity of slice() is O(n).
Syntax:
slice(start, stop, step)
where start refers to the start index from where you have to copy, stop refers to the index till where you want to slice, and step refers to the count by which you want to skip.
For Example:
a=”Hello World”
y=slice(2,4,1)
print(y)
Output:
lo
4) sorted()
This function sorts the given element in specified (ascending or descending) order. The set of elements could be a list, tuple, and dictionary. The time complexity of the sorted function is O(n.logn).
Syntax:
sorted(set of elements)
where a set of elements refers to the elements which need to be sorted.
For Example:
a=[1,7,3,8]
y=sorted(a)
print(y)
Output:
[1,3,7,8]
5) split()
This method breaks up the string into a list of substrings, based on the specified separator. It returns strings as a list. By default, whitespace is the separator. Time complexity of split() is O(n).
Syntax:
split(separator)
where separator refers to the value which is to be split from the given sequence.
For Example:
a=”HelloWorld”
y=a.split(‘l’)
print(y)
Output:
['He','oWor','d']
6) eval()
The eval() function evaluates the given expression whether it is a mathematical or logical expression. If a string is passed through it, it parses the function, compiles it to bytecode, and then returns the output. Since operators have no time complexity therefore eval doesn’t have one.
Syntax:
eval(expression)
where the expression could be any operation such as mathematical or logical.
For Example:
x=6
y=eval(‘x*8’)
print(y)
Output:
48
7) bin()
This function converts an integer to a binary string that has the prefix 0b. Also, the integer passed could be negative or positive. Its time complexity for a number n is O(log(n))
Syntax:
bin(integer)
where the integer is any value passed to receive its binary form.
For Example:
print(bin(8))
Output:
0b1000
8) map()
This function returns a map object(which is an iterator) of the results after applying the given function to each item of a given iterable (list, tuple, etc.). It applies a function to all objects in a list. The time of complexity of the map() function is O(n).
Syntax:
map(function, iterable)
where function refers to the function which will be used in a program, iterable refers to the value that will be iterated in the program.
For Example:
def add(x):
return x+2
x = map(add, (3, 5, 7, 11, 13))
print (x)
Output:
(2,7,9,13,15)
9) filter()
This function creates a new iterator from an existing one (such as a list, tuple, or dictionary) that filters elements. It checks whether the given condition is available in the sequence or not and then prints the output. The time complexity of the filter function is O(n).
Syntax:
filter(function, iterable)
where function refers to the function which will be used in a program, iterable refers to the value that will be iterated in the program.
For Example:
c = [‘Ant’,’Lizard’,’Mosquito’,’Snake’]
def vowels(x):
return x[0].lower() in ‘aeiou’
items = filter(vowels, c)
print(list(items))
Output:
['Ant']
10) exec()
This function executes the given condition and prints the output in python expression. It executes the program dynamically Python exec() function executes the dynamically created program, which is either a string or a code object. If it is a string, then it is parsed as a Python statement and then executed; else, a syntax error occurs.
Syntax:
exec(object[, globals[, locals]])
where the object can be a string or object code, globals can be a dictionary and the parameter is optional, and locals can be a mapping object and are also optional.
For Example:
exec(print(sum(2,8)))
Output:
10
So till now you must have got the information about 10 Python in-built functions. With these in-built functions, you can make complex applications very easy. Use it whenever you’re working on any Python application to be handy.
