# Built-In Functions and Methods

## Contents

# Built-In Functions and Methods#

Built-in functions are, as the name implies, already a part of the Python library. These are functions that are so commonly used that you just need to *call* them in order to use them yourself! We have already seen a few examples of built-in functions including `print()`

and `type()`

. There are some mathematical built-in functions, for example we can find the maximum or minimum of given numbers, or the absolute value of a single number. We can even round floating point numbers to a specified decimal. Additionally, there are functions that give us general information about the input, such as the length of a string or the type of the input object.

To call a built-in function, we use the function name with parentheses around the function input. For example the function name for maximum is `max()`

and calling this function takes the format below.

```
max(...)
```

Functions take arguments as input, and if we are unsure what arguments a function accepts, there’s a built-in function for that! The `help()`

function. This function accepts a function as input and outputs the key characterics, namely what it takes as input and what it outputs. Calling the `help`

function on `max`

, we see we can enter two or more arguments and we expect the largest argument to be returned. We can alternately enter an iterable argument, like a sequence, dicussed in detail in Chapter 4: Data Structures.

```
help(max)
```

```
Help on built-in function max in module builtins:
max(...)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.
```

So we can call the `max`

function with multiple arguments and it returns the max. Below, we call the max function with three arguments and the largest value is returned.

```
max(2, 4.1, -3)
```

```
4.1
```

Below is a short list of common built-in functions. For a more complete list see the Python documentation here: Built-in Function Documentation

Built-in Python Functions |
Description |
---|---|

max(…) |
Maximum function: Returns the maximum of the given inputs. |

min(…) |
Minimum function: Returns the maximum of the given inputs. |

sum(…) |
Sum function: Returns the sum of a given iterable. |

abs(…) |
Absolute value function: Returns the absolute value of the given input. |

round(…) |
Rounding function: Returns the rounded input. |

len(…) |
Length function: Returns the length of given input. |

type(…) |
Data Type function: Returns the datatype of the input. |

print(…) |
Print function: Prints the input |

# Libraries#

There are a lot of functions and tools that are not contained directly in Python. If we want to access more specific functions or if we want to manipulate particular objects, we may have to import a library or a module. A **module** is a collection of functions and code that are related in some way, while a **library** is a collection of modules that are helpful in performing tasks. While there is a distinction, we will use library throughout this textbook to encompass both.

For example, there are numerous mathematical functions that are not built-in to Python, but are still important and common. We can gain access to them by importing the math library. This gives us access to the exponential, logarithmic, square root, and even floor and ceiling functions, in addition to storing the number pi or computing factorials. Hence we can think of these functions as being built-in to their respective libraries.

We will see later that we can import a library, `matplotlib`

, to assist with graphing or visualing data, or the `numpy`

library which allows us access to different types of objects and their manipulation. Throughout this textbook, we will import libraries as needed.

# Math Library#

To access the functions built in to the math library, we first import the library by running the line below.

```
import math
```

Since these functions are coming from the math library, to call them we use

```
math.name_of_function
```

For example, suppose we want to compute log(5). Using the math library, we write the following line.

```
math.log(5)
```

```
1.6094379124341003
```

To check the key aspects of the function, we can again use the help function to view the documentation regarding

```
math.log(...)
```

Note, to ensure the input to the help function is itself a function, we do not input an argument for log.

```
help(math.log)
```

```
Help on built-in function log in module math:
log(...)
log(x, [base=math.e])
Return the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.
```

Did the log function do as we intended? Well, based on the documentation, if we do not specifiy the base,

```
math.log(5)
```

is the natural logarithm, \(\ln(5)\). Typing \(\log(5)\) on your calculator assumes base 10, which we can mimic by specifing the argument for the base for the optional argument of the math.log function.

```
math.log(5, 10)
```

```
0.6989700043360187
```

So it is important to know the default values for these built-in functions!

A few of the more common math functions are included below; for a complete list see the documentation here Built-in Math Function Documentation.

Built-in Math Functions |
Description |
---|---|

math.log(…) |
Returns log of input. If no base is specified uses base \(e\). |

math.exp(…) |
Returns \(e\) to the power of the input. |

math.sqrt(…) |
Returns the square root of the input. |

math.floor(…) |
Returns the floor of the input. |

math.ceil(…) |
Returns the ceiling of the input. |

math.factorial(…) |
Returns the factorial of the input. |

math.pi |
Returns pi. |

math.e |
Returns \(e\). |

Since the output of these math functions are in fact numbers, we can manipulate them however we want!

```
math.factorial(6)/math.floor(12.9879) + math.pi
```

```
63.1415926535898
```

# Methods#

Methods are similar to functions in that they provide an output based on some input. However, a major difference is that methods are built on specific *objects* and can easily modify the original input *object*. The format for a method is

```
object.method()
```

where *method* performs some action on *object*. Objects can be datatypes like strings, or more complicated data structures.
As we previously saw, we can define the string *candy* and use the `.replace()`

method to modify the original string object.

```
candy = "candy is my favorite treat. my favorite candy is BUBBLE GUM."
candy.replace("BUBBLE GUM", "LICORICE")
```

```
'candy is my favorite treat. my favorite candy is LICORICE.'
```

And there are many methods made for string datatypes. Some common string methods are seen in the table below.

Built-in Methods on Strings |
Description |
---|---|

string.replace(‘old’, ‘new’) |
Replaces any ‘old’ elements with ‘new’ in the given string |

string.upper() |
Returns an uppercase version of the given string |

string.lower() |
Returns a lowercase version of the given string |

string.strip() |
Returns the given string with additional spaces at beginning or end removed |

We will see methods acting on different objects throughout this book as we delve deeper into the structure of Python.

Note all of the tools used in this section are built-in to various libraries or directly within Python. If we want to repeat our own process or perform an action and we cannot find a premade function, we also have the option to create our own functions!