Python Functions Tutorial: Working With Functions in Python
- 2019-02-05 02:54 PM
- 73
In this Python functions post, the goal is to get you the expertise required to get started and work with functions using Python. Let's get started!
In today’s fast-paced IT world, it is always an advantage to have an edge over the others in terms of in-depth knowledge of a certain technology. Python is a widely used language and provides ‘n’ number of opportunities to enthusiastic learners.
In this Python functions post, the goal is to get you the expertise required to get started and work with functions using Python. I will be covering the following topics in this Python functions article:
-
Why We Need Python Functions
-
What Python Functions Are
-
Types of Python Functions
-
Built-in Functions in Python
-
Python Recursive Functions
-
Python Lambda Functions
-
User-defined Functions in Python
Why We Need Python Functions
Functions manage the inputs and outputs in computer programs. Programming languages are designed to work on data and functions are an effective way to manage and transform this data.
The modifications are generally done to drive outcomes like performing tasks and finding results. And, the set of operations or instructions required to do so comes from logically functional blocks of code that can be reused independently from the main program.
In fact, the main code is also a function, just a very important one. Every other function is logically aligned and maintained to functionally execute from your main code. But, if the function has not been defined, you’ll just have to define one yourself before using it. This is because the definition lists the steps of its operation.
Would you rather write a single piece of code 10 times or just once and use it 10 times?
So, functions are nothing but tasks that a user wants to perform. But, defining it once with a name will let you reuse that functionality without making your main programs look too scary. This drastically reduces lines of code and even makes debugging easier.
We’ll be getting into that shortly, but the first reason behind why we use functions is because of their reusability. The fact that even complex operations could be put together as singular tasks that would run with just a call by its name is what has made code today so much clearer as well.
Every programming language lets you create and use these functions to perform various tasks with just a call. And, you could call it any number of times without having to worry about logically structuring its code into your main code every single time.
Say, you have a television that stores many channels on it, receives their digital radio broadcasts, converts them into what we watch, while also giving us additional options for a variety of other features as well.
But that doesn’t mean there is someone logically scripting the lines of codes for what you watch every time you turn on your tv or flip a channel. Rather, functions for each task have been logically defined once and keep getting reused time and again according to the features you try to use.
All of this happens by calling different functions as many times as needed from the main function that is running. So, even if you’re turning the volume up or down, its defined function is being called repeatedly.
And, having a system operating the main code to keep calling these functions as and when needed has also made designing and innovating upon it easier.
The important thing to note is that whenever this function is called, it executes its tasks depending on the instructions specified in it.
That’s why machines can have different functions. A calculator is probably the most common example of this. It has provisions for addition, subtraction, multiplication, division, and other functions. All its functions have been clearly predefined into it, but it only performs those that you choose to call by pressing a respective button.
Programmers reduce coding time and debugging time, thereby reducing overall development time, by using functions.
Next up on this Python functions post, let’s look at what Python functions actually are.
What Are Python Functions?
The functions in Python are a classic example of the reusability discussed above. So, to serve a wide range of applications from GUI and mathematical computing to web development and testing, Python’s interpreter already comes equipped with numerous functions that are always available for use. And, you could also bring in other libraries or modules to your program that contain pre-defined functions readily available for use.
All you’ll really have to do is download required packages.
So, once defined, a function can be used any number of times at any point in any of your code. Now, this is because Python falls in-line with the DRY principle of software engineering, which aims to replace any repetition of software patterns or codes with abstractions to avoid redundancy and ensure that they can be used freely without revealing any inner details of their implementation.
DRY stands for Don’t Repeat Yourself and this concept of having reusable blocks of codes is very crucial for achieving abstraction in Python. Thus, in order to use a function, all that you’ll really need is its name, its purpose, its arguments (if it takes any), and its result’s type (if it returns any).
It’s almost like using an automobile or a telephone, where you don’t necessarily need to understand the working of its components to use them. Rather, they’ve been built to serve common purposes that you can just use directly to achieve your goals and devote your precious time to implementing all the innovative aspects of your application.
A function can be called as a section of a program that is written once and can be executed whenever required in the program, thus giving us code reusability.
The function is a subprogram that works on data and produces some output.
To define a Python function, you’d have to use the def
keyword before the name of your function and add parentheses to the end, followed by a colon.
Python uses indentation to indicate blocks, instead of brackets, to make code more readable.
A function in Python may contain any number of parameters or none. So, when you need your function to operate on variables from other blocks of code or from your main program, it could take any number of parameters and produce results.
A Python function could also optionally return a value. This value could be a result produced from your function’s execution or even be an expression or value that you specify after the keyword ‘return
.’ And, after a return statement is executed, the program flow goes back to the state next to your function call and gets executed from there.
So, to call a Python function at any place in your code, you’ll only have to use its name and pass arguments in its parentheses, if any.
The rules for naming a function are the same as naming a variable. It begins with either letter from A-Z, a-z in both upper and lower cases or an underscore(_
). The rest of its name can contain underscores(_
), digits(0-9), and any letters in upper or lower case.
- A reserved keyword may not be chosen as an identifier.
- Good usage of grammar to ensure enhanced readability of code.
It is good practice to name a Python function according to what it does.
Next up in this Python functions post, let us check out the types of functions available in Python.
Types of Python Functions
There are many types of Python functions. And each of them is very vital in its own way. The following are the different types of Python Functions:
- Python Built-in Functions.
- Python Recursion Functions.
- Python Lambda Functions.
- Python User-defined Functions.
Let us check out these functions in detail. Beginning with Built-in functions as they are very easy to understand and implement.
Python’s Built-In Functions
The Python interpreter has a number of functions that are always available for use. These functions are called built-in functions. For example, the print()
function prints the given object to the standard output device (screen) or to the text stream file.
In Python 3.6, there are 68 built-in functions. But for the sake of simplicity, let’s consider the most popular functions and we can build up our knowledge from there.
Python abs() Function
Definition
The abs()
function returns the absolute value of the given number. If the number is a complex number, abs()
returns its magnitude.
Syntax
The syntax of the abs()
is:
abs(num)
Parameters
The abs()
function takes a single argument:
- integer
- floating number
- complex number
Example
# random integer
integer = -20
print('Absolute value of -20 is:', abs(integer))
#random floating number
floating = -30.33
print('Absolute value of -30.33 is:', abs(floating))
Output
Absolute value of -20 is: 20 Absolute value of -30.33 is: 30.33
Python all() Function
Definition
The all()
function returns True
when all elements in the given iterable are true. If not, it returns False
.
Syntax
The syntax of the all()
is:
all(iterable)
Parameters
The all()
function takes a single parameter:
Example
# all values true
l = [1, 3, 4, 5]
print(all(l))
# all values false
l = [0, False]
print(all(l))
# one false value
l = [1, 3, 4, 0]
print(all(l))
# one true value
l = [0, False, 5]
print(all(l))
# empty iterable
l = []
print(all(l))
Output
True False False False True
Python ascii() Function
Definition
The ascii()
function returns a string containing a printable representation of an object. It escapes the non-ASCII characters in the string using \x, \u or \U escapes.
Syntax
The syntax of ascii()
is:
ascii(object)
Parameters
The ascii()
function takes an object (like strings, lists, etc).
Example
normalText = 'Python is interesting'
print(ascii(normalText))
otherText = 'Pythön is interesting'
print(ascii(otherText))
print('Pyth\xf6n is interesting')
Output
'Python is interesting' 'Pyth\xf6n is interesting' Pythön is interesting
Python bin() Function
Definition
The bin()
function converts and returns the binary equivalent string of a given integer. If the parameter isn’t an integer, it has to implement the __index__()
method to return an integer.
Syntax
The syntax of the bin()
is:
bin(num)
Parameters
The bin()
function takes a single parameter:
Example
number = 5
print('The binary equivalent of 5 is:', bin(number))
Output
The binary equivalent of 5 is: 0b101
Python compile() Function:
Definition
The compile()
function returns a Python code object from the source (normal string, a byte string, or an AST object).
Syntax
The syntax of compile()
is:
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
Parameters
source
- a normal string, a byte string, or an AST object.filename
- file from which the code was read. If it wasn’t read from a file, you can give a name yourself.mode
- Eitherexec
oreval
orsingle
.eval
- accepts only a single expression.exec
- It can take a code block that has Python statements, classes, functions, and so on.single
- if it consists of a single interactive statement.
flags
(optional) anddont_inherit
(optional) - controls which future statements affect the compilation of the source. Default Value: 0.optimize
(optional) - optimization level of the compiler. Default value -1.
Example
codeInString = 'a = 5\nb=6\nsum=a+b\nprint("sum =",sum)'
codeObejct = compile(codeInString, 'sumstring', 'exec')
exec(codeObejct)
Output
sum = 11
Python dict() Function
Definition
dict()
creates a dictionary in Python.
Different forms of dict()
are:
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
Example
numbers = dict(x=5, y=0)
print('numbers = ',numbers)
print(type(numbers))
empty = dict()
print('empty = ',empty)
print(type(empty))
Output
empty = dict() print('empty = ',empty) print(type(empty))
Python enumerate() Function
Definition
The enumerate()
function adds a counter to an iterable and returns it (the enumerated object).
Syntax
The syntax of enumerate()
is:
enumerate(iterable, start=0)
Parameters
The enumerate()
function takes two parameters:
- **iterable **- a sequence, an iterator, or objects that support iteration.
- **start **(optional) -
enumerate()
starts counting from this number. If start is omitted, 0 is taken as the start.
Example
grocery = ['bread', 'milk', 'butter']
enumerateGrocery = enumerate(grocery)
print(type(enumerateGrocery))
# converting to list
print(list(enumerateGrocery))
# changing the default counter
enumerateGrocery = enumerate(grocery, 10)
print(list(enumerateGrocery))
Output
<class 'enumerate'>
[(0, 'bread'), (1, 'milk'), (2, 'butter')]
[(10, 'bread'), (11, 'milk'), (12, 'butter')]
Python eval() Function
Definition
The eval()
function parses the expression passed to this function and runs a Python expression (code) within the program.
Syntax
The syntax of the eval()
is:
eval(expression, globals=None, locals=None)
Parameters
eval()
takes three parameters:
- **expression **- this string is parsed and evaluated as a Python expression.
- globals(optional) - a dictionary.
- locals(optional) - a mapping object. Dictionary is the standard and commonly used mapping type in Python.
Example
x = 1
print(eval('x + 1'))
Output
sum = 11
Python filter() Function:
Definition
The filter()
function constructs an iterator from elements of an iterable for which a function returns true.
Syntax
The syntax of filter()
is:
filter(function, iterable)
Parameters
The filter()
function takes two parameters:
- **function **- function that tests if elements of an iterable return true or false. If none, the function defaults to the Identity function — which returns false if any elements are false
- **iterable **- iterable which is to be filtered, could be sets, lists, tuples, or containers of any iterators.
Example
# list of letters
letters = ['a', 'b', 'd', 'e', 'i', 'j', 'o']
# function that filters vowels
def filterVowels(alphabet):
vowels = ['a', 'e', 'i', 'o', 'u']
if(alphabet in vowels):
return True
else:
return False
filteredVowels = filter(filterVowels, letters)
print('The filtered vowels are:')
for vowel in filteredVowels:
print(vowel)
Output
The filtered vowels are:
a
e
i
o
Python getattr() Function:
Definition
The getattr()
function returns the value of the named attribute of an object. If not found, it returns the default value provided to the function.
Syntax
The syntax of getattr()
is:
getattr(object, name[, default])
Parameters
The getattr()
function takes multiple parameters:
- **object **- object whose named attribute’s value is to be returned.
- **name **- string that contains the attribute’s name.
- **default (Optional) **- value that is returned when the named attribute is not found.
Example
class Person:
age = 23
name = "Adam"
person = Person()
print('The age is:', getattr(person, "age"))
print('The age is:', person.age)
Output
The age is: 23
The age is: 23
Python help() Function
Definition
The help()
function calls the built-in Python help system.
The syntax of help()
is:
help(object)
Parameters
The help()
function takes the maximum of one parameter.
- object (optional) – you want to generate the help of the given
object
Example
>>> help('print')
Python id() Function
Definition
The id()
function returns identity (unique integer) of an object.
Syntax
The syntax of id()
is:
id(object)
Parameters
The id()
function takes a single parameter object.
Example
class Foo:
b = 5
dummyFoo = Foo()
print('id of dummyFoo =',id(dummyFoo))
Output
id of dummyFoo = 140343867415240
Python len() Function
Definition
The len()
function returns the number of items (length) in an object.
Syntax
The syntax of len()
is:
len(s)
Parameters
s - a sequence (string, bytes, tuple, list, or range) or a collection (dictionary, set or frozen set)
Example
testList = []
print(testList, 'length is', len(testList))
testList = [1, 2, 3]
print(testList, 'length is', len(testList))
testTuple = (1, 2, 3)
print(testTuple, 'length is', len(testTuple))
testRange = range(1, 10)
print('Length of', testRange, 'is', len(testRange))
Output
[] length is 0
[1, 2, 3] length is 3
(1, 2, 3) length is 3
Length of range(1, 10) is 9
Python max() Function
Definition
The max()
function returns the largest element in an iterable or largest of two or more parameters.
Syntax
The syntax of max()
is:
max(iterable, *iterables[,key, default])
max(arg1, arg2, *args[, key])
Parameters
max()
has two forms of arguments it can work with.
max(iterable, *iterables[, key, default])
- iterable- sequence (tuple, string), collection (set, dictionary) or an iterator object whose largest element is to be found.
- ***iterables (Optional) **- any number of iterables whose largest is to be found.
- key (Optional) - a key function where the iterables are passed and the comparison is performed based on its return value.
- **default (Optional) **- default value if the given iterable is empty.
max(arg1, arg2, *args[, key])
- **arg1 **- mandatory first object for comparison (could be number, string or another object).
- **arg2 **- mandatory second object for comparison (could be number, string or another object).
- ***args (Optional) **- other objects for comparison.
- key- key function where each argument is passed and the comparison is performed based on its return value
Example
# using max(arg1, arg2, *args)
print('Maximum is:', max(1, 3, 2, 5, 4))
# using max(iterable)
num = [1, 3, 2, 8, 5, 10, 6]
print('Maximum is:', max(num))
Output
Maximum is: 5
Maximum is: 10
Python min() Function
Definition
The min() function returns the smallest element in an iterable or smallest of two or more parameters.
The syntax of min()
is:
min(iterable, *iterables[,key, default])
min(arg1, arg2, *args[, key])
Parameters
min()
has two forms of arguments it can work with.
min(iterable, *iterables[, key, default])
- iterable- sequence (tuple, string), collection (set, dictionary) or an iterator object whose smallest element is to be found.
- ***iterables (Optional) **- any number of iterables whose smallest is to be found.
- key (Optional) - a key function where the iterables are passed and the comparison is performed based on its return value.
- default (Optional)- default value if the given iterable is empty.
min(arg1, arg2, *args[, key])
- **arg1 **- mandatory first object for comparison (could be number, string or another object)
- **arg2 **- mandatory second object for comparison (could be number, string or another object)
- ***args (Optional) **- other objects for comparison
- **key **- a key function where each argument is passed and a comparison is performed based on its return value
Example
# using min(arg1, arg2, *args)
print('Minimum is:', min(1, 3, 2, 5, 4))
# using min(iterable)
num = [3, 2, 8, 5, 10, 6]
print('Minimum is:', min(num))
Output
Minimum is: 1
Minimum is: 2
Python oct() Function
Definition
The oct()
function takes an integer number and returns its octal representation. If the given number is an int, it must implement the __index__()
method to return an integer.
The syntax of oct()
is:
oct(x)
Parameters
The oct()
function takes a single parameter x.
This parameter could be:
- an integer number (binary, decimal or hexadecimal).
- if not an integer, must implement
__index__()
method to return an integer.
Example
# decimal number
print('oct(10) is:', oct(10))
# binary number
print('oct(0b101) is:', oct(0b101))
# hexadecimal number
print('oct(0XA) is:', oct(0XA))
Output
oct(10) is: 0o12
oct(0b101) is: 0o5
oct(0XA) is: 0o12
Python pow() Function
Definition
The pow()
function returns x to the power of y. If the third argument (z) is given, it returns x to the power of y modulus z, i.e. pow(x, y) % z.
The syntax of pow() is:
pow(x, y[, z])
Parameters
The pow()
function takes three parameters:
- **x **- number which is to be powered.
- **y **- number which is to be powered with x.
- **z (Optional) **- number which is to be used for modulus operation.
Example
# positive x, positive y (x**y)
print(pow(2, 2))
# negative x, positive y
print(pow(-2, 2))
# positive x, negative y (x**-y)
print(pow(2, -2))
# negative x, negative y
print(pow(-2, -2))
Output
4
4
0.25
0.25
Python reversed() Function
Definition
The reversed()
function returns the reversed iterator of the given sequence.
The syntax of reversed()
is:
reversed(seq)
Parameters
The reversed()
function takes a single parameter:
- seq – sequence that should be reversedCould be an object that supports sequence protocol (
__len__()
and__getitem__()
methods) as a tuple, string, list, or range. It could be an object that has implemented__reversed__()
.
Example
# for string
seqString = 'Python'
print(list(reversed(seqString)))
# for tuple
seqTuple = ('P', 'y', 't', 'h', 'o', 'n')
print(list(reversed(seqTuple)))
# for range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# for list
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
Output
['n', 'o', 'h', 't', 'y', 'P']
['n', 'o', 'h', 't', 'y', 'P']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
Python sum() Function
Definition
The sum()
function returns the reversed iterator of the given sequence.
The syntax of sum()
is:
sum(iterable, start)
Parameters
- **iterable **- iterable (list, tuple, dict, etc) whose item’s sum is to be found. Normally, items of the iterable should be numbers.
- **start **(optional) - this value is added to the sum of items of the iterable. The default value of start is 0 (if omitted).
Example
numbers = [2.5, 3, 4, -5]
# start parameter is not provided
numbersSum = sum(numbers)
print(numbersSum)
# start = 10
numbersSum = sum(numbers, 10)
print(numbersSum)
Output
4.5
14.5
Python type() Function
Definition
If a single argument (object) is passed to type()
, it returns the type of the given object. If three arguments (name, bases, and dict) are passed, it returns a new type object. The syntax of type()
is:
type(object)
type(name, bases, dict)
Parameters
- If the single object argument is passed to
type()
, it returns the type of the given object.
Example
numberList = [1, 2]
print(type(numberList))
numberDict = {1: 'one', 2: 'two'}
print(type(numberDict))
class Foo:
a = 0
InstanceOfFoo = Foo()
print(type(InstanceOfFoo))
Output
<class 'dict'>
<class 'Foo'>
Next up on this Python functions series, we’ll check out the Recursive Function in Python.
Learn More
☞ Complete Python Bootcamp: Go from zero to hero in Python 3
☞ Learn Python by Building a Blockchain & Cryptocurrency
☞ Python and Django Full Stack Web Developer Bootcamp
☞ The Python Bible™ | Everything You Need to Program in Python
☞ Learning Python for Data Analysis and Visualization
☞ Python for Financial Analysis and Algorithmic Trading
☞ The Modern Python 3 Bootcamp
Original source: https://dzone.com