Functions Flashcards
What are functions?
A handy way of taking a complex set of instructions and packaging them
together inside a block of code that has a name given to them
Is written to complete a specific task
What are 3 advantages of using functions?
- Helps organize code into blocks
- Making the program more readable and easier to update or modify
- Functions can be reused, preventing redundancy
Functions in Python are defined using the “___” keyword, followed by the
function name and parentheses
The parentheses may contain “_______” parameters
Def
Optional
What is the syntax for defining a function in python?
Syntax:
def function_name(parameter1, parameter2, …):
# Function code
The function code block consists of statements and can contain any valid
Python code
The function code can include variable declarations, control flow statements, and other function calls
A colon is used to indicate the beginning of the function’s code block
Function calls are made by using the function name followed by parentheses
What does this look like? After you define the first function
Example:
def my_first_function():
# Do this…
# Do that…
# Do something else…
my_first_function()
How do we modify a function (a message)?
We need to look more closely at the parenthesis in the function call
We can add the name of a variable inside those parenthesis
This variable, with the value passed in, can then be used inside the function definition
Ex.
def my_first_function(something):
# Do this with something…
# Do that with something…
# Do something else…
my_first_function(123)
^ Vaule of 123 gets passed to something
In this example…
def my_first_function(something):
# Do this with something…
# Do that with something…
# Do something else…
My_first_function(123)
Something is the “_________”
123 is the “_________”
Something is the parameter
= is the name of the data that is being passed to the function
123 is the argument
= is the data that is being passed to the function
Functions can have “________” parameters and be called with multiple “________”
What does this look like?
Multiple; arguments
def my_first_function(something, anotherthing):
# Do this with something…
# Do that with something…
# Do something else with anotherthing…
my_first_function(123, 789)
What are positional arguments?
Give an example
They are the most basic type of arguments in python
They are passed to a function based on their position or order
They order of the arguments MATTER & must MATCH the functions parameter order
def my_first_function(a, b, c, d):
# Do this with a…
# Do that with b…
# Do something else with c and d…
my_first_function(1, 2, 3, 4)
w/in the function:
a = 1
b = 2
c = 3
d =4
my_first_function(2, 3, 4, 1)
w/in the function:
a = 2
b = 3
c = 4
d = 1
In the function we wrote, “local_good_morning(name, location)”…
What happens when you change the order of arguments that are passed into the function?
The answer of the name and location SWITCH places the the written statement
What are keyword arguments?
Give an example
Keyword arguments allow you to pass arguments to a function using
their parameter names
The arguments are specified as key-value pairs, separated by commas
This way, you can pass arguments in any order
Keyword arguments make the code more readable and self- explanatory
However, it makes your code a bit longer
def my_first_function(a, b, c, d):
# Do this with a…
# Do that with b…
# Do something else with c and d…
my_first_function(a=1, b=2, c=3, d=4)
a = 1
b = 2
c = 3
d = 4
my_first_function(b=2, c=3, d=4, a=1)
a = 1
b = 2
c = 3
d = 4
What is variable scope in functions?
Give an example
Variable scope refers to the accessibility and visibility of variables within a program
Variables defined inside a function have different scopes
Local scope
= is the scope of variables defined inside a function
Variables declared inside a function are accessible only within that
function
They cannot be accessed outside the function
Example of local scope of variable
“message”:
def greet():
message = “Hello, World!” # Local variable
print(message)
greet()
print(message) # Error: NameError: name ‘message’ is not defined
Functions can call other functions, what does this mean?
Give an example
A function call executes the code within the called function
This allows for code reuse and modular programming
Functions are called by using their name followed by parentheses
The called function’s code is executed before returning to the calling
function
Ex:
def greet():
print(“Hello!”)
def welcome():
greet()
print(“Welcome!”)
welcome() # Calling the welcome()function
Give an example of a local variable scope
def funcB(a,b):
a = 2
b = 3
print(“Inside funcB a,b = “, a, b)
def funcA():
a = 10
b = 20
funcB(a,b)
print(“Inside funcA a,b = “, a, b)
funcA()
OUTPUT:
Inside funcB a,b = 2 3
Inside funcA a,b = 10 20
What is the “return” statement in python and what does it do?
Give an example
It allows functions to send back a value as output
By using the return statement,
= a function can provide a result or data to the caller
The return statement is followed
= by the value or expression to be returned
When the return statement is encountered
= the function immediately exits
The returned value can be stored in a variable or used directly.
Ex:
def add(a, b):
return a + b
result = add(3, 4)
print(result)
# Output: 7
What are multiple return values?
Give an example
A function can return multiple values by separating them with commas
The returned values:
= can be assigned to multiple variables
Ex:
def calc_circle_properties(radius):
circumference = 2 * 3.14159265 * radius
area = 3.14159265 * radius * radius
return circumference, area
circumference, area = calc_circle_properties(7)
print(“Circumference:”, circumference)
print(“Area:”, area)
Output:
Circumference: 43.982297100000004
Area: 153.93803985000002
What are variables local to functions?
Give an example
Local variables are defined within a function and have local scope
They are only accessible within the function where they are defined
Local variables can have the same name as global variables without any conflict
= they are considered separate entities
When accessing a variable within a function…
= python searches for the
variable locally (within the function scope) before checking the global
scope
Ex:
def foo(x):
y = 1
x += 5
print(“in foo() y=”,y)
print(“in foo() x=”,x)
x = 10
foo(x)
print(“x=”,x)
#print(“y=”,y)
#This statement would give an error because y was local to foo()
