Python Lecture 4

Creative Commons License
This work is licensed under a Creative Commons Attribution 4.0 International License.
BS GIS Instructor: Inzamam Baig
Lecture 4
Fundamentals of Programming

Functions
A function is a named sequence of statements that performs a
computation
When you define a function, you specify the name and the
sequence of statements
Later, you can “call” the function by name
>>> type(32)

Built-in functions
Python provides a number of important built-in functions that we
can use without needing to provide the function definition
The creators of Python wrote a set of functions to solve common
problems and included them in Python for us to use
>>> max(10, 100)
100
>>> min(10,100)

Type conversion functions
Python also provides built-in functions that convert values from one type to
another
The int function takes any value and converts it to an integer, if it can, or
complains otherwise
>>> int('32')
32
>>> int('Hello')
ValueError: invalid literal for int() with base 10: 'Hello'

int can convert floating-point values to integers, but it doesn’t
round off; it chops off the fraction part
>>> int(3.99999)
3
>>> int(-2.3)
-2

float converts integers and strings to floating-point numbers
>>> float(32)
32.0
>>> float('3.14159')
3.14159

Finally, str converts its argument to a string
>>> str(32)
'32'
>>> str(3.14159)
'3.14159'

Math functions
Python has a math module that provides most of the familiar
mathematical functions
>>> import math
This statement creates a module object named math
>>> print(math)
<module 'math' (built-in)>

>>> ratio = signal_power / noise_power
>>> decibels = 10 * math.log10(ratio)
>>> radians = 0.7
>>> height = math.sin(radians)

>>> degrees = 45
>>> radians = degrees / 360.0 * 2 * math.pi

Random Numbers
The random module provides functions that generate
pseudorandom numbers
The function random returns a random float between 0.0 and 1.0
(including 0.0 but not 1.0)
import random
x = random.random()
print(x)

The random function is only one of many functions that handle
random numbers
The function randint takes the parameters low and high, and returns
an integer between low and high (including both)
>>> random.randint(5, 10)
5
>>> random.randint(5, 10)
9

To choose an element from a sequence at random, you can use
choice
>>> t = [1, 2, 3]
>>> random.choice(t)
2
>>> random.choice(t)
3

Adding new Functions
A function definition specifies the name of a new function and the
sequence of statements that execute when the function is called.
Once we define a function, we can reuse the function over and
over throughout our program
def print_words():
print(“Inside a function.")

def is a keyword that indicates that this is a function definition
rules for function names are the same as for variable names:
letters, numbers and some punctuation marks are legal, but the
first character can’t be a number
You can’t use a keyword as the name of a function, and you
should avoid having a variable and a function with the same
name

def print_words():
print(“Inside a function.")
The empty parentheses after the name indicate that this function doesn’t take any
arguments
The first line of the function definition is called the header
The rest is called the body
The header has to end with a colon and the body has to be indented
By convention, the indentation is always four spaces

Functions in Interactive Mode
If you type a function definition in interactive mode, the interpreter
prints ellipses (. . .)
to let you know that the definition isn’t complete
>>> def print_words():
... print("Inside a function.")

>>> print(print_words)
>>> print(type(print_words))

Calling a Function
>>> print_words()

Calling a function from another function
def repeat_words():
print_words()
print_words()
>>> repeat_words():

Parameters and Arguments
Some of the built-in functions we have seen require arguments.
For example, when you call math.sin you pass a number as an
argument.
Some functions take more than one argument: math.pow takes
two, the base and the exponent
Inside the function, the arguments are assigned to variables
called parameters

Parameters and Arguments
def print_twice(name):
print(name)
print(name)
This function assigns the argument to a parameter named name.
When the function is called, it prints the value of the parameter
(whatever it is) twice

>>> print_twice('Adnan')
Adnan Adnan
>>> print_twice(30)
30 30
>>> import math
>>> print_twice(math.pi)

>>> print_twice('Spam '*4)
Spam Spam Spam Spam
Spam Spam Spam Spam
>>> print_twice(math.cos(math.pi))

You can also use a variable as an argument:
>>> department = ‘Computer Science.'
>>> print_twice(department)
Computer Science.
Computer Science.

Fruitful functions and void functions
Functions that perform an action but don’t return a value. They
are called void functions

>>> math.sqrt(5)
This script computes the square root of 5, but since it doesn’t
store the result in a variable or display the result, it is not very
useful.
Void functions might display something on the screen or have
some other effect, but they don’t have a return value. If you try to
assign the result to a variable, you get a special value called
None

But in a script, if you call a fruitful function and do not store the
result of the function in a variable, the return value vanish
The value None is not the same as the string “None”. It is a
special value that has its own type:
>>> print(type(None))

Return Value
To return a result from a function, we use the return statement in our
function. For example, we could make a very simple function called
addtwo that adds two numbers together and returns a result
def addtwo(a, b):
added = a + b
return added
x = addtwo(3, 5)
print(x)

Why functions?
• Creating a new function gives you an opportunity to name a group of
statements, which makes your program easier to read, understand,
and debug.
• Functions can make a program smaller by eliminating repetitive
code. Later, if you make a change, you only have to make it in one
place.
• Dividing a long program into functions allows you to debug the parts
one at a time and then assemble them into a working whole.
• Well-designed functions are often useful for many programs. Once
you write and debug one, you can reuse it.

Python Lecture 4

More Related Content

What's hot

Similar to Python Lecture 4

More from Inzamam Baig

Recently uploaded

Python Lecture 4

Editor's Notes