Decomposition part 2 Flashcards
Difference between
age = seven
print (seven)
and
age = “seven”
print (seven)
In Python, quotation marks are used to denote string literals. When you assign a value to a variable using quotation marks, you are assigning a string value to that variable. For example:
If you don’t use quotation marks, Python assumes that you are referring to a variable name. When you write age = seven, Python interprets seven as a variable and tries to find its value. If there is no variable named seven defined, it raises a NameError because it cannot find the variable.
To assign a string value to the age variable, you need to use quotation marks.
age = seven means “set the value of the variable age to the value of the variable seven”. age = “seven” means “set the value of the variable age to the string “seven”.
How can you acess local variables outside of a function?
Parameter Passing
Whate does parameter passing do?
Passes a copy of the contents of a variable as the function is called
What does parameter passing communicate?
Communicate information about local variables
Format for parameter passing
List the names of the variables in the round brackets that will store the name of the information passed in
Format:
def <Function> (parameter 1, parmeter 2......)</Function>
Parameters are mention in the —– while the actual arguments are passed during —-
- function definition
- a function call
Each parameters creates variables that are….
local to the function
Passing variables or named constants:
What it looks like+ex
Just specify the name of the identifier
e.g. print(num), random.ranrange(MIN, MAX)
Passing unnamed constants:
What it looks like+ex
Just specify the value of the parameter
e.g. input(“Enter your name: “), print (“Hello”)
You can’t pass —– parameters
negative
In this program, how many local variables do we have
def fun(num1):
print(num1)
num2= 20
print(num2)
def start(): num1=1 fun(num1) start()
To summarize, when passing parameters to a function in Python, you are passing references to the objects.
We have 3 local variables, 2 in fun and 1 in start
Even if the parameters are unnamed in the sense that they don’t have explicit variable names associated with them, you can still pass their values as arguments to functions using either positional or keyword arguments. Give me an example and tell me how it works:
print (“Lucy”)
input (“Enter your name”)
Whats the output?
def myfunc():
x = 300
def myinnerfunc():
print(x)
myinnerfunc()
myfunc()
In the example, the variable x is not available outside the function, but it is available for any function inside the function:
The inner function myinnerfunc() can access the variable x defined in the outer function myfunc(). This behavior is known as “lexical scoping” or “closure” in Python.
300
Whats the output?
x = 300 def myfunc(): x = 200 print(x) myfunc() print(x)
200
300
Does local variables get used first or global?
In Python, when a variable is referenced within a function, the interpreter first looks for that variable’s value within the local scope of the function. If the variable is not found in the local scope, the interpreter then searches for it in the global scope.
We only use the input() function when
There’s mention of user input
def fun(parameter1, parameter2):
print (parameter1, parameter2)
fun (1, 123)
or:
def fun (a, b):
print (a, end= " ")
print (b)
fun("hi", "love")
which is correct?
def fun(parameter1, parameter2):
print (parameter1, parameter2)
fun ("1", "123")
and
def fun(parameter1, parameter2):
print (parameter1, parameter2)
fun (1, 123)
Both versions of the code are correct, but they have different parameter values.
In the first version:
def fun(parameter1, parameter2):
print(parameter1, parameter2)
fun(“1”, “123”)
The function fun is called with string arguments “1” and “123”. When executed, it will print “1 123”. In this case, the parameters parameter1 and parameter2 are treated as strings.
In the second version:
def fun(parameter1, parameter2):
print(parameter1, parameter2)
fun(1, 123)
The function fun is called with integer arguments 1 and 123. When executed, it will print 1 123. In this case, the parameters parameter1 and parameter2 are treated as integers.
So, the choice between the two versions depends on whether you want to pass and treat the parameters as strings or integers. Both are correct, but the behavior and output of the function will differ.
Write me a celsius to frahrenheit converter with functions
def introduction():
print("""
Celsius to Fahrenheit converter
This program will convert a given Celsius temperature to an equivalent
Fahrenheit value.
""")
-
def display(celsius, fahrenheit):
print("")
print("Celsius value: ", celsius)
print("Fahrenheit value:", fahrenheit)
def convert():
celsius = float(input("Type in the celsius temperature: "))
fahrenheit = celsius * (9 / 5) + 32
display(celsius, fahrenheit)
def start():
introduction()
convert()
start()How many variables in this code:
convert (fahrenheit, celsius)
display (fahrenheit, celsius)
4 variables
Fix this:
using return values for multiple values format:
A function will immediately end and return back to the caller if: (2)
- a return instructuion is encountered (return can be empty)
- There are no more instructions in the function. (Aka change in indenting as it exit the function)
Just because a functio returns a value does not automatically mean the return value will be usable by the caller of that function. Function return value must be…..+ex (2)
explicitly saved by the caller of the function
Parameter passing is used to…
pass info into a function before the function executes (during the function call).
Parameters are copied into….
variables that are local to the function
Passing variable vs returning difference
Return values are used to
communicate info out of a function as the function ends (going back/returning to a caller)
The return value must be
stored in the caller of the function
Boolean Functions
Not performing an action but asking a question.
Ex:
isNum()
*you pass a parameter to it, a string, and it determine if the string can be converted to a number.”
Camel case
+ex
Naming system that capitalize the first letter of each word except the first
ex: toUpper()
