Function Calls
In the context of programming, 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. We have
already seen one example of a function call:
>>> type(32)
<class
'int'>
The name of the function is type. The expression in parentheses is called the
argument of the
function. The argument is a value or variable that we are passing
into the function as input to the function. The result, for the type function, is the
type of the argument.
It is common to say that a function “takes” an argument and “returns”
a result.
The
result is called the return
value.
Use Case Diagram of Function for more understanding of the function
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.
Python Functions:
•
In Python a function is some reusable code that
takes arguments(s) as input, does some computation, and then returns a result
or results
•
We define a function using the def reserved word
•
We call/invoke the function by using the
function name, parentheses, and arguments in an expression
•
There are two kinds of functions in Python.
- Built-in functions that are provided as part
of Python - print(), input(), type(), float(), int() ...
- Functions that we define ourselves and then
use
•
We treat function names as “new” reserved words
(i.e., we avoid them as variable names)
Type Conversions:
•
When you put an integer and floating point in an
expression, the integer is implicitly converted to a float
•
You can control this with the built-in functions
int() and float()
String Conversions:
•
You can also use int() and float() to convert
between strings and integers
•
You will get an error if the string does not
contain numeric characters
Building our Own Functions:
•
We create a new function using the def keyword
followed by optional parameters in parentheses
•
We indent the body of the function
•
This defines the function but does not execute
the body of the function
Definitions and Uses:
•
Once we have defined a function, we can call (or
invoke) it
as many times as we like
•
This is the store and reuse pattern
Arguments:-
•
An argument is a value we pass into the function
as its input when we call the function
•
We use arguments so we can direct the function
to do different kinds of work when we call it at different times
•
We put the arguments in parentheses after the name
of the function
•
big = max('techshoot03')
Parameters:-
A parameter is a variable which we use in the function definition. It is a “handle” that allows the code in the function
to access the arguments for a particular function invocation.
>>> def greet(lang):
... if lang ==
'es':
... print('Hola')
... elif lang
== 'fr':
... print('Bonjour')
... else:
... print('Hello')
...
>>> greet('en')
Hello
>>> greet('es')
Hola
>>> greet('fr')
Bonjour
>>>
Return Values: -
Often a function will take its arguments, do some
computation, and return a value to be used as the value of the function call in
the calling expression. The return
keyword is used for this.
def greet():
return
"Hello"
print(greet(), "Glenn")
print(greet(), "Sally")
>>> def greet(lang):
... if lang ==
'es':
... return 'Hola'
... elif lang
== 'fr':
... return 'Bonjour'
... else:
... return 'Hello'
...
>>> print(greet('en'),'Glenn')
Hello Glenn
>>> print(greet('es'),'Sally')
Hola Sally
>>> print(greet('fr'),'Michael')
Bonjour Michael
>>>
Multiple Parameters / Arguments : -
•
We can define more than one parameter in the function
definition
•
We simply add more arguments when we call the function
•
We match the number and order of arguments and
parameters
Void (non-fruitful) Functions:-
•
When a function does not return a value, we call
it a “void” function
•
Functions that return values are “fruitful”
functions
•
Void functions are “not fruitful”
To function or not to function...
•
Organize your code into “paragraphs” - capture a
complete thought and “name it”
•
Don’t repeat yourself - make it work once and
then reuse it
•
If something gets too long or complex, break it
up into logical chunks and put those chunks in functions
•
Make a library of common stuff that you do over
and over - perhaps share this with your friends...
•
Functions
•
Built-In Functions
•
Type conversion (int, float)
•
String conversions
•
Parameters
•
Arguments
•
Results (fruitful functions)
•
Void (non-fruitful) functions
•
Why use functions?
No comments:
Post a Comment