PINOY BLAST
WELCOME TO
PINOY BLAST COMMUNITY!!
PINOYBLAST CLAN MEMBER TAG:
SITE: PB|NICK
UZZAP: +PB|^NICK
Search

Display results as :

Who is online?
In total there is 1 user online :: 0 Registered, 0 Hidden and 1 Guest

None

Most users ever online was 14 on Wed Apr 23, 2014 10:25 am
feeds

Social bookmarking

Bookmark and share the address of KiLL ALL TRIBE.....EXCEPT BaTan6TRiBE on your social bookmarking website

Bookmark and share the address of PINOY BLAST on your social bookmarking website

# FUNCTIONS TUTORIAL

## FUNCTIONS TUTORIAL

Functions Introduction
What are functions? Well, in effect, functions are little self-contained programs that perform a specific task, which you can incorporate
into your own, larger programs. After you have created a function, you
can use it at any time, in any place. This saves you the time and
effort of having to retell the computer what to do every time it does a common task, for example getting the user to type something in.
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 x 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 is 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
Lets 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 is is you want if it is option 1: ask for
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 verion 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:
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 "Thankyou 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.)
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 seperate 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?

1. when 'def hello()' was run, a function called 'hello' was created
2. When the line 'print hello()' was run, the function 'hello' was executed (The code inside it was run)
3. The function 'hello' printed "hello" onscreen, then returned the number '1234' back to the main program
4. 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.
Passing Parameters to functions
There is one more thing we will cover in this (monsterously huge)
lesson - passing parameters to a function. Think back to how we defined
functions:
Code Example 12 - Defining functions with parameters

def function_name(parameter_1,parameter_2): {this is the code in the
function} {more code} {more code} return {value (e.g. text or number) to

Where parameter_1 and parameter_2 are (between the parentheses), you
put the names of variables that you want to put the parameters into.
Put as many as you need, just have them seperated by commas. When you
run a function, the first value you put inside the parentheses would go
into the variable where parameter_1 is. The second one (after the
first comma) would go to the variable where parameter_2 is. This goes
on for however many parameters there are in the function (from zero, to
the sky) For example:
Code Example 13 - how parameters work

def funnyfunction(first_word,second_word,third_word): print "The word
created is: " + first_word + second_word + third_word return first_word +
second_word + third_word

When you run the function above, you would type in something like this:
funnyfunction("meat","eater","man"). The first value (that is, "meat")
would be put into the variable called first_word. The second value
inside the brackets (that is, "eater") would be put into the variable
called second_word, and so on. This is how values are passed from the
main program to functions - inside the parentheses, after the function
name.
A final program Think back to that calculator program. Did it look a bit messy to you? I think it did, so lets re-write it, with functions.

To design - First we will define all the functions we are going to use
with the 'def' operator (still remember what an operator is
). Then we will have the main program, with all that messy code
replaced with nice, neat functions. This will make it so much easier to
look at again in the future.
Code Example 14 - Calculator program

# calculator program # NO CODE IS REALLY RUN HERE, IT IS ONLY TELLING
US WHAT WE WILL DO LATER # Here we will define our functions # this
prints the main menu, and prompts for a choice def menu(): #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 "
" return input ("Choose your option: ") # this adds two numbers given
def add(a,b): print a, "+", b, "=", a + b # this subtracts two numbers
given def sub(a,b): print b, "-", a, "=", b - a # this multiplies two
numbers given def mul(a,b): print a, "*", b, "=", a * b # this divides
two numbers given def div(a,b): print a, "/", b, "=", a / b # NOW THE
PROGRAM REALLY STARTS, AS CODE IS RUN loop = 1 choice = 0 while loop ==
this: ")) elif choice == 2: sub(input("Subtract this:
"),input("from this: ")) elif choice == 3: mul(input("Multiply this:
"),input("by this: ")) elif choice == 4: div(input("Divide this:
"),input("by this: ")) elif choice == 5: loop = 0 print "Thankyou
for using calculator.py!" # NOW THE PROGRAM REALLY FINISHES

The initial program had 34 lines of code. The new one actually had 35
lines of code! It is a little longer, but if you look at it the right
way, it is actually simpler.

You defined all your functions at the top. This really isn't part of
your main program - they are just lots of little programs, that you will
call upon later. You could even re-use these in another program if you
needed them, and didn't want to tell the computer how to add and
subtract again.

If you look at the main part of the program (between the line 'loop =
1' and 'print "Thankyou for..."'), it is only 15 lines of code. That
means that if you wanted to write this program differently, you would
only have to write 15 or so lines, as opposed to the 34 lines you would
normally have to without functions.
Tricky Ways You Can Pass Parameters Finally, as a bit of an interlude, I will explain what the line add(input("Add this: "),input("to this: ")) means.

I wanted to fit everything onto one line, with as few variables as
possible. Remember what functions look like to the main program?
Whatever value they return. If the numbers you passed to the add()
function were 2 and 30, the main program would see this:
Code Example 15 - The results of fancy parameter work

The add program would then run, adding 2 and 30, then printing the
result. The add program has no 'return' operator - it doesn't return
anything to the main program. It simply adds two numbers and prints
them onscreen, and the main program doesn't see anything of it.
Instead of (input("Add this: "),input("to this: ")) as the parameters for the add program you could have variables. E.g.
Code Example 16 - variables as parameters
num1 = 45 num2 = 7 add(num1,num2)

For the above, remember that the function you are passing the variables
to cannot change the variables themselves - they are simply used as
values. You could even put the values straight into the function:
Code Example 17 - the end result

This is because the only thing the function sees are the values that
are passed on as parameters. Those values are put into the variables
that are mentioned when 'add' is defined (the line 'def add(a,b)' ).
The function then uses those parameters to do it's job.
In short:

• The only thing functions see of the main program is the parameters that are passed to it
• the only thing the main program seens of functions is the returned value that it passes back

Conclusion WHOA!!!! WHAT A KILLER LESSON!!! But we got through it, and I made minimal typos. Great!

SIGNATURE:

___________________________________________________________________________

KAMOTE
PINOYBLAST

Posts : 204
PINOY BLAST Coins : 47512
Join date : 22/10/2010
Age : 23
Location : BATANGAS

Permissions in this forum:
You cannot reply to topics in this forum