functions-1
What is function?
A function is a block of
organized, reusable code that is used to perform a single, related action.
Functions provides better modularity for your application and a high degree of
code reusing. As you already know, Python gives you many built-in functions
like print() etc. but you can also create your own functions. These functions
are called user-defined functions.
Defining a Function:
You
can define functions to provide the required functionality. Here are simple
rules to define a function in Python:
Ø
Function blocks begin with the keyword def
followed by the function name and parentheses ( ( ) ).
Ø
Any input parameters or arguments should be
placed within these parentheses. You can also define parameters inside these
parentheses.
Ø
The first statement of a function can be an
optional statement - the documentation string of the function or docstring.
Ø
The code block within every function starts with
a colon (:) and is indented.
Ø
The statement return [expression] exits a
function, optionally passing back an expression to the caller. A return
statement with no arguments is the same as return None.
Syntax:
def
functionname( parameters ):
"function_docstring"
function_suite
return [expression]
By default,
parameters have a positional behavior, and you need to inform them in the same
order that they were defined.
Using a function:
Python has lots of pre-made
functions, that you can use right now, simply by 'calling' them. 'Calling' a
function involves you giving a function input, and it will return a value (like
a variable would) as output. Don't understand? Here is the general form that
calling a function takes:
Code Example 1 - How to call a function
function_name(parameters)
See? Easy.
Ø function_name identifies which function
it is you want to use (you'd figure...). For example, the function raw_input,
which will be the first function that we will use.
Ø Parameters are the values you pass to
the function to tell it what is should do, and how to do it.. for example, if a
function multiplied any given number by five, the stuff in parameters tells the
function which number it should multiply by five. Put the number 70 into
parameters, and the function will do 70×5.
Parameters and Returned Values - Communicating with
Functions:
Well,
that's all well and good that the program can multiply a number by five, but
what does it have to show for it? A warm fuzzy feeling? Your program needs to
see the results of what happened, to see what 70 x 5 is, or to see if there is
a problem somewhere (like you gave it a letter instead of a number). So how
does a function show what it does?
Well,
in effect, when a computer runs a function, it doesn't actually see the
function name, but the result of what the function did. Variables do the exact
same thing - the computer doesn't see the variable name, it sees the value that
the variable holds. Lets call this program that multiplied any number by five,
multiply(). You put the number you want multiplied in the brackets. So if you
typed this:
Code Example 2 - Using a function
a = multiply(70)
The computer would actually see this:
Code Example 3 - What the computer sees
a = 350
Note: don't bother typing in this code - multiply() isn't a real
function, unless you create it.
The
function ran itself, then returned a number to the main program, based on what
parameters it was given.
Now
let's try this with a real function, and see what it does. The function is
called raw_input, and asks the user to type in something. It then turns it into
a string of text. Try the code below:
Code Example 4 - Using raw_input
# this line makes 'a' equal to whatever you type in
a = raw_input("Type in something, and
it will be repeated on screen:")
# this line prints what 'a' is now worth
print a
Say in the above program, you typed in 'hello' when it asked you to
type something in. To the computer, this program would look like this:
Code Example 5 - What the computer sees
a = "hello"
print "hello"
Remember,
a variable is just a stored value. To the computer, the variable 'a' doesn't
look like 'a' - it looks like the value that is stored inside it. Functions are
similar - to the main program (that is, the program that is running the
function), they look like the value of what they give in return of running.
A Calculator Program:
Let's write another program, that will act as
a calculator. This time it will do something more adventerous than what we have
done before. There will be a menu, that will ask you whether you want to
multiply two numbers together, add two numbers together, divide one number by
another, or subtract one number from another. Only problem - the raw_input
function returns what you type in as a string - we want the number 1, not the
letter 1 (and yes, in python, there is a difference.).
Luckily,
somebody wrote the function input, which returns what you typed in, to the main
program - but this time, it puts it in as a number. If you type an integer (a
whole number), what comes out of input is an integer. And if you put that
integer into a variable, the variable will be an integer-type variable, which
means you can add and subtract, etc.
Now,
lets design this calculator properly. We want a menu that is returned to every
time you finish adding, subtracting, etc. In other words, to loop (HINT!!!)
while (BIG HINT!!!) you tell it the program should still run.
We
want it to do an option in the menu if you type in that number. That involves
you typing in a number (a.k.a input) and an if loop.
Lets write it out in understandable English first:
Code Example 6 - human-language example
START PROGRAM
print opening message
while we let the program run, do this:
#Print what options you have
print Option 1 - add
print Option 2 - subtract
print Option 3 - multiply
print Option 4 - divide
print Option 5 - quit program
ask for which option it is you want
if it is option 1:
ask for first number
ask for second number
add them together
print the result onscreen
if it is option 2:
ask for first number
ask for second number
subtract one from the other
print the result onscreen
if it is option 3:
ask for first number
ask for second number
multiply!
print the result onscreen
if it is option 4:
ask for first number
ask for second number
divide one by the other
print the result onscreen
if it is option 5:
tell the loop to stop looping
Print onscreen a goodbye message
END PROGRAM
Lets put this in something that Python can understand:
Code Example 7 - Python version of menu
#calculator program
#this variable tells the loop whether it should loop or not.
# 1 means loop. anything else means don't loop.
loop = 1
#this variable holds the user's choice in the menu:
choice = 0
while loop == 1:
#print what options you have
print "Welcome to calculator.py"
print "your options are:"
print " "
print "1) Addition"
print "2) Subtraction"
print "3) Multiplication"
print "4) Division"
print "5) Quit calculator.py"
print " "
choice = input("Choose your option: ")
if choice == 1:
add1 = input("Add this: ")
add2 = input("to this: ")
print add1, "+", add2, "=", add1 + add2
elif choice == 2:
sub2 = input("Subtract this: ")
sub1 = input("from this: ")
print sub1, "-", sub2, "=", sub1 - sub2
elif choice == 3:
mul1 = input("Multiply this: ")
mul2 = input("with this: ")
print mul1, "*", mul2, "=", mul1 * mul2
elif choice == 4:
div1 = input("Divide this: ")
div2 = input("by this: ")
print div1, "/", div2, "=", div1 / div2
elif choice == 5:
loop = 0
print "Thank you for using
calculator.py!"
Wow!
That is an impressive program! Paste it into Python IDLE, save it as
'calculator.py' and run it. Play around with it - try all options, entering in
integers (numbers without decimal points), and numbers with stuff after the
decimal point (known in programming as a floating point). Try typing in text,
and see how the program chucks a minor fit, and stops running (That can be
dealt with, using error handling, which we can address later.)
Define Your Own Functions:
Well, it is all well and good that you can use other people's functions, but
what if you want to write your own functions, to save time, and maybe use them
in other programs? This is where the 'def' operator comes in. (An operator is
just something that tells python what to do, e.g. the '+' operator tells python
to add things, the 'if' operator tells python to do something if conditions are
met.)
This is how the 'def' operator works:
Code Example 8 - The def operator
def function_name(parameter_1, parameter_2):
{this is the code in the function}
{more code}
{more code}
return {value to return to the main
program}
{this code isn't in the function}
{because it isn't indented}
#remember to put a colon ":" at the end
#of the line that starts with 'def'
function_name
is the name of the function. You write the code that is in the function below
that line, and have it indented. (We will worry about parameter_1 and
parameter_2 later, for now imagine there is nothing between the parentheses.
Functions run completely independent of the main program. Remember when
I said that when the computer comes to a function, it doesn't see the function,
but a value, that the function returns? Here's the quote:
Functions
run completely independent of the main program. Remember when I said that when
the computer comes to a function, it doesn't see the function, but a value,
that the function returns? Here's the quote:
To
the computer, the variable 'a' doesn't look like 'a' - it looks like the value
that is stored inside it. Functions are similar - to the main program (that is,
the program that is running the function), they look like the value of what
they give in return of running.
A
function is like a miniture program that some parameters are given to - it then
runs itself, and then returns a value. Your main program sees only the returned
value. If that function flew to the moon and back, and then at the end had:
Code Example 9 - return
return "Hello"
then all your program would see is the
string "hello", where the name of the function was. It would have no
idea what else the program did.
Because
it is a separate program, a function doesn't see any of the variables that are
in your main program, and your main program doesn't see any of the variables
that are in a function. For example, here is a function that prints the words
"hello" onscreen, and then returns the number '1234' to the main
program:
Code Example 10 - using return
# Below is the function
def hello():
print "hello"
return 1234
# And here is the function being used
print hello()
Think about the last line of code above. What did it do? Type in the
program (you can skip the comments), and see what it does. The output looks
like this:
Code Example 11 - the output
hello
1234
So what happened?
Ø when 'def hello()' was run, a function
called 'hello' was created.
Ø When the line 'print hello()' was run,
the function 'hello' was executed (The code inside it was run) .
Ø The function 'hello' printed
"hello" onscreen, then returned the number '1234' back to the main
program.
Ø The main program now sees the line as
'print 1234' and as a result, printed '1234
That
accounts for everything that happened. remember, that the main program had NO
IDEA that the words "hello" were printed onscreen. All it saw was
'1234', and printed that onscreen.
No comments:
Post a Comment