10710_Build_in_Functions

Use of predefined functions¶

After we getting to know about operators and their usage in Python we want introduce the use of functions in Python.

Built-in functions¶

Built-in functions are predefined, provided codes that are distributed together with Python. These functions will make your life a lot easier because you do not have to implement frequently and commonly used codes at your own. In this understanding they expand the possibilities given by the introduced operators. So let's get started!

Functions for every data type¶

Functions are written for a specific data type. Data types in general and in Python will be introduced in the next chapters. As a starting point it is sufficient to know that there exist different data types for varying purposes and that not every function works for every data type. With your already learned knowledge you will see that there are specialized functions that only work for numbers and others that only work for characters. Besides this there are also functions that work for all datatypes. We want to start with these.

Note: A function is used by typing the name of the function and putting the value (formally known as argument) in brackets:

Function to get the data type of a variable type():

In [1]:

a_word = "hello"
a_number = 9

In [2]:

# we expect String as datatype
type(a_word)

Out[2]:

str

In [3]:

# as 9 is a number, we expect an according datatype (int == Integer)
type(a_number)

Out[3]:

int

Function to display the content of a variable or more general the given argument print():

In [4]:

print(a_word)

hello

In [5]:

print(a_number)

Functions for numbers¶

As we want to introduce Python as a calculator we want to have a closer look at functions that work for numbers.

Note: Only very few functions are available by default in Python. Most functions are conflated in dedicated modules. To use these functions you must load the required module first. A specific module is loaded with the import command. You can find a list of all Python modules in the Python documentation.

To get access to commonly used mathematical function for calculations we must load the math module at first:

In [6]:

import math

Note: It is recommented to import modules with an alias. This will allow yourself and others to identify from which module or package a function is used. This is especially important if there are two function from two different modules with the same name. That's why we want to adapt our import statement a little bit:

In [7]:

import math as m

Function to get the absolute value of a number abs():

In [8]:

abs(9 - 12)

Out[8]:

Function to calculate the square root of a number sqrt():

In [9]:

m.sqrt(64)

Out[9]:

8.0

Function to get a specific value based on the $e$ function exp():

In [10]:

m.exp(1)

Out[10]:

2.718281828459045

Function to get the logarithm to the base of $e$ log():

In [11]:

m.log(10)

Out[11]:

2.302585092994046

Function to calculate the logarithm to the base of $10$ log10():

In [12]:

m.log10(1000)

Out[12]:

3.0

Function to calculate the logarithm to a user defined base log(<value>, <base>):

In [13]:

m.log(81, 3)

Out[13]:

4.0

Note: As you can see it is also possible to call a function with more than one argument. If you want to call a function with more than one argument you have to seperate each argument by ,. In general: function(<argument_1>, <argument_2>, ... ,<argument_n>)

Using mathematical constants like $\pi$:

In [14]:

m.pi

Out[14]:

3.141592653589793

Note: constants are a special type of variable. They differ in so far that the actual value of a constant cannot be changed after it is assigned. Because constants, like variables, are a storage for values they are used without brackets.

besides $\pi$ the following constants are provided over the math package:

Mathematical constant	Python correspondent
$e$	`math.e`
$\tau$	`math.tau`
$\infty$	`math.inf`

Trigonometric functions (arguments in radians) sin(), cos(), tan():

In [15]:

m.sin(m.pi / 2)

Out[15]:

1.0

In [16]:

m.cos(m.pi / 2)

Out[16]:

6.123233995736766e-17

In [17]:

m.tan(0)

Out[17]:

0.0

Inverse trigonometric functions asin(), acos(), atan():

In [18]:

m.asin(0)

Out[18]:

0.0

In [19]:

m.acos(1)

Out[19]:

0.0

In [20]:

m.atan(m.pi)

Out[20]:

1.2626272556789115

Exercise: Check whether the cosine of 360° within the unit circle is 1!

In [21]:

### your solution

In [22]:

Show code

m.cos(2 * m.pi)

Function to round x to n decimal places round(<number>, <decimal_places>):

In [23]:

round(m.pi, 2)

Out[23]:

3.14

Function to round down to the nearest integer number floor():

In [24]:

m.floor(m.pi)

Out[24]:

Function to round up to the nearest integer number ceil():

In [25]:

m.ceil(m.pi)

Out[25]:

Advanced Exercise: Consider Earth as a ball with a radius of 6371 km and calculate the distance between two meridians at the equator and at 23 degree. Round your answer to 1 decimal place! Bear in mind that the trigonometric functions in R expect angles in radians!

In [26]:

### your solution

In [27]:

Show code

distance_equator = round((2 * m.pi * 6371) / 360 * m.cos((m.pi / 180) * 0), 1)
print("The distance between two meridians at the equator is", distance_equator, "km.")

In [28]:

distance_23_degree = round((2 * m.pi * 6371) / 360 * m.cos((m.pi / 180) * 23), 1)
print("The distance between two meridians at the 23 degree is", distance_23_degree, "km.")

The distance between two meridians at the 23 degree is 102.4 km.

Summary¶

A summary of all introduced functions is given below.

Python function	Mathematical correspondent
`abs(9)`	\|$9$\|
`math.sqrt(64)`	$\sqrt {64}$
`math.exp(2)`	$e^2$
`math.log(5)`	$\ln(5)$
`math.log10(1000)`	$\log_{10}(1000)$
`math.log(27, 3)`	$\log_{3}(27)$
`math.sin(math.pi)`	$\sin(\pi)$
`math.cos(math.pi)`	$\cos(\pi)$
`math.tan(math.pi)`	$\tan(\pi)$
`math.asin(math.pi)`	$\arcsin(\pi)$
`math.acos(math.pi)`	$\arccos(\pi)$
`math.atan(math.pi)`	$\arctan(\pi)$

Citation

The E-Learning project SOGA-Py was developed at the Department of Earth Sciences by Annette Rudolph, Joachim Krois and Kai Hartmann. You can reach us via mail by soga[at]zedat.fu-berlin.de.

You may use this project freely under the Creative Commons Attribution-ShareAlike 4.0 International License.

Please cite as follow: Rudolph, A., Krois, J., Hartmann, K. (2023): Statistics and Geodata Analysis using Python (SOGA-Py). Department of Earth Sciences, Freie Universitaet Berlin.