Module 0.10.0 - Functional Programming

• a method of programming using funcitons

• function, a statement that [typically] takes an input, uses that input to perform an operation, and will return some output.

print("Hello, World")
>>> Hello, World

functions are typically structured as a statement, followed by some parenthesis "()"

0.10.1 - Defining and Calling Functions

• in python, and most programming languages, we can make our own functions

• in order to do this, we must define them

• "def" statement, defines function

# defines function
def my_func():
	print("Hello, World!")

• now we that we have a function defined, we can call it

• functions are called by placing the name of the function, followed by parenthesis "()"

my_func()
>>> "Hello, World!"

• functions can be called multiple times

0.10.2 - Working With Arguments

• functions can take argument, allows for ease of use and optimal code

• argument, data that is inputted into a function [of some sort]

  • arguments [can] serve as varibles, only available in the functions scope

# this function squares numbers, "number" is the argument
def squared(number):
	print(number**2)
	
squared(2)
squared(3)
squared(4)

>>> 4
>>> 9
>>> 16

• multiple arguments can be used within a function.

• each argument is seperated by a comma.

# this function will add two numbers together
def add_together(num1, num2):
	print(num1 + num2)
	
add_together(1, 2)

>>> 3

0.10.3 - Returning Data

• functions can return data that can be assigned and used in operations

• "return" statement, returns data that can be used in operetions

  • the function will stop once the "return" statement is used

# this function will double a number and return the value
def double(num):
	return num * 2

print(double(2))
>>> 4

• the function can now be used as an object, argument, or value; because it can be assigned a value

four = double(2)
multiply_by_2 = double
print(multiply_by_2(5))
print(multiply_by_2(four))

>>> 10
>>> 8

• the 'double' function above is a pure function, this is because it returns a value that only depends on the arguments attached

  • pure functions are more ideal in the programming world

• an impure function depends on an external value or datatpype

message = "Hello, "
def impure_function(text):
	return message + text 
	
greeting = impure_function
greeting("World!")

>>> "Hello, World!"

0.10.4 - Higher-Order Functions

a type of function that utilizes another function as an argument

# normal function
def talk(message):
	return message

uppercase_msg = talk
uppercase_msg("Hello, World!")

# higer-order function
def message(func):
	uppercase_msg = func("Hello, World")
	print(uppercase_msge)
	
message(talk)

>>> Hello, World!
>>> Hello, World

• this allows us to make our functions versatile, and add more functionality

• we can use this same example to output different types of text.

def title_case(text):
	return text.title()
	
def lower_case(text):
	return text.lower()
	
def upper_case(text):
	return text.upper()
	
def message(case, text):
	output = case(text)
	print(output)

hw = "Hello, World!"
message(upper_case, hw) 
message(lower_case, hw)
message(title_case, hw)

>>> HELLO, WORLD!
>>> hello, world!
>>> Hello, World!

0.10.5 - Special Arguments

• python has special arguments we can use in our functions

• defined arguments, assinging default values to arguments

  • in the event that they are not defined, avoids error

• defining arguments can be done with the assigment operator "="

def profile(name = "Enter name", age = "Enter age", status = "Enter status"):
	return f"Name : {name}\nAge : {age}\nStatus : {status}\n"
	
bobs_account = profile("bob", "25")
joes_account = profile("Joe", "48", "single")

print(bobs_account)
print(joes_account)

• "*" args argument, allows you to pass an undefined amount of arguments to a function, and assigns them to a tuple labled after your args variable name

  • the default is "args"

def class_schedule(mandatory_class, *args):
	print(f"Period 1: {mandatory_class}")
	
	period_number = 2
	
	for course in args:
		print(f"Period {period_number}: {course}")
		period_number += 1
		
class_schedule("Homeroom", "Math", "Science", "English", "History")

>>> Period 1: Homeroom
>>> Period 2: Math
>>> Period 3: Science
>>> Period 4: English
>>> Period 5: History

• "**" kwargs argument, passes defined arguments into a dictionary labled after your kwarg variable name

  • the default is "kwargs"

• dictionary key = argument name, dictionary value = argument value

def groceries(store_name, **kwargs):
    print("\n"+store_name)
    for food, price in kwargs.items():
        print(f"{food} --> {price}")
		
groceries("Giant", apples = "$1.50", oranges = "$2.50", bananas = "$1.75")
groceries("Publix", apples = "$1.00", oranges = "$3.50", bananas = "$2.00")

>>> Giant
>>> apples --> $1.50
>>> oranges --> $2.50
>>> bananas --> $1.75
>>> 
>>> Publix
>>> apples --> $1.00
>>> oranges --> $3.50
>>> bananas --> $2.00

0.10.6 - __main__

• allows your code to be both imported into other projects and scripts, or can run as is

• the conditional if __name__ == "__main__:" detects if the code is being ran or imported, respectively

  • the attached expression will run if the code is being ran

• let's make a file called 'script.py' and run it

• script.py syntax

def double(n):
	return n*2
	
def main():
	# write main code in here
	print(f"2 doubled is {double(2)}")
	
if __name__ == "__main__":
	main()
	
>>> "2 doubled is 4"

• we can now effeciently import other dictionaries it into another file

• calculator.py syntax

import script # name of file [in same directory]

print(script.double(4))

>>> 8

0.10.7 - Mapping and Filtering

• "map" function, use each item in a list as an argument to a function

  • the first argument is the function

  • the second argument is the iterable

def double(n):
	return n * 2
	
numbers = [1, 2, 3, 4]
mapped_list = map(double, numbers)
print(list(mapped_list))

>>> [2, 4, 6, 8]

• "filter" function, iterates through a list, only returns values that follow a certain argument

  • the first argument is the function

  • the second argument is the iterable

def even(n):
	return n % 2 == 0
	
numbers = [1, 2, 3, 4]
filtered_list = filter(even, numbers)
print(list(filtered_list))

>>> [2, 4]

0.10.8 - Lambda

• a less powerful function that works in one line

  • can take in many arguments but only returns one expression

double = lambda x : x * 2
double(2)
double(3)
double(4)

>>> 4
>>> 6
>>> 8

• lambda's can take more than one argument

add_together = lambda x, y = x + y
add_together(3, 7)

>>> 10

• lambda's aren't always assigned to varaibles

• they can be used as arguments for functions

num_list = list(range(-10, 11))
positive_values = list(filter(lambda x: x > 0, num_list))
print(positive_values)

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]