# Chapter4.py

# Functions page 106 - 116

'''
Functions are reusable blocks of code that return the value to the function itself. 

We define a new function with the def keyword.
The function DOES NOT have to be defined in the same module as where you call it from.

There are 3 options to import your functions to another module
import ModuleName -> ModuleName is the filename without the extension (.py)
example: Orders.py -> import Orders

import ModuleName as Namespace/Alias -> You have to access the objects in the module thru the namespace in your code. You will NOT see the module name in any access drop downs in the IDE.
example: Cart.py -> import Cart as myCart
myCart.objectName
!access Cart.objectName

from ModuleName import ObjectName -> If the object is a function/method, you just call the name, not the tuple
def myCalculator() in a file called Shipping.py
example: from Shipping import myCalculator

option 1 -> you can put the imports on their own line
import Cart # commments
import Shipping
import Orders

option 2 -> you can call multiple objects and modules on the same line
import Cart, Shipping, Orders
from Orders import shipto, billto, orderdetails # sometimes this is ok

Functions use tuples to pass data. Chapter 6 page 194. We use tuples because tuples are immutable, aka they can not be added, updated or deleted from.
(param1, param2, ....) !CUD


There are 3 types of parameters for functions
myFunction() -> empty function, where no data is being passed to the function.
myFunction(param1, param2, ...) -> parameterized function, where data is being passed from args -> params
myFunction(param1, param2, param3="defaultValue") -> Query string parameter or Default parameter. All the default parameters in Python must be at the end. If data is passed by the arg, the arg value is used, if no arg is passed, the function uses the default.
example: 
def contactInfo(firstName, lastName, state="Florida", vipStatus=False)
arg contactInfo("Bob", "Smith", state*, True) Bob Smith Florida True
arg contactInfo("Jane","Doe", "Iowa", True) Jane Doe Iowa True
arg contactInfo("Mary","Jones") Mary Jones Florida False

The arguments (args) MUST be passed left to right in the position id
'''
# value -> variable -> args -> params -> scopeVar -> functionScope

firstName = "Bob" # var = value
lastName = "Smith"

# create an object for the arg
# optional -> you could make the tuple for the function (firstName, lastName)
fName = firstName # arg = var
lName = lastName

# argName that is being injected into the param (if dynamic) must be set in memory and the same name as the getter (param)   fName -> fName

# We have discovered that we are breaking the DRY principle
# Define a function for the concept of reusable code
# def func_fullName(firstName, lastName) # !Law of Demeter  lv=param
def func_fullName(fName, lName): # param(arg)
    # pass # pass keyword is a placeholder for empty operations
    # what data we need in this functions scope (the indentation)
    sVar_fName = fName
    sVar_lName = lName
    result_fullName = f"{sVar_fName} {sVar_lName}"
    print(result_fullName)

'''
Workflow example for a function
i_fName = input("Enter contact first name: ")
i_lName = input("Enter contact last name: ")

param_fName = i_fName # injector -> param 
param_lName = i_lName

def expected_fullName(param_fName, param_lName):
    var_fName = param_fName
    var_lName = param_lName
    result_fullName = f"{var_fName} {var_lName}" # view look like
    print(result_fullName) # Bob Smith

'''
# Report 1
'''
fullname = f"{firstName} {lastName}"
print(fullname)
'''
# replace the old fullname process with our new function
func_fullName(firstName, lastName) 

print("======")

# Web Page
''''
web_fullName = f"{firstName} {lastName}"
print(web_fullName)
'''
# call the new function that has the reusable code for full name
func_fullName(firstName, lastName)

print("======")

# EOF