- CB 3.12,3.13 Developing Procedures

What is a procedure?

A procedure is a named group of code that has paramaters and return values. Procedures are known as methods or functions depending on the language.

A procedure executes the statements within it on the parameters to provide a return value.

What are parameters?

Paramaters are input values of a procedure that are specified by arguments.Arguments specify the values of the parameters when a procedure is called.

By creating theses algorithms the readibility of code increases and the complexity decreases. This is becasue a function’s name can tell the reader what action it will perform, and by calling it, the code becomes more clean and easy to understand.

What is a return value?

A return value is the value that is returned when a function or a method is called.

That return value can be assigned or printed

Procedures are used to create algorthims that can perform certain actions or return values. When a procedure returns a value, theis information must be stored in a variable for later use. However some procedures like the MOVE_FORWARD() perform an action, and don’t return a value. The image above provides an example of where procedures that don’t output a value would be used.

A 60$ item recieves a 20% discount and taxed at 8%.
PROCEDURE applyDiscount(cost, percentDiscounted).   
{
    temp ← 100 - percentDiscounted
    temp← temp/ 100
    cost ← cost *temp
    RETURN(cost)
}

price ← applyDiscount(60, 20)
This is how we get the final price with the discount by calling the procedure and assigning it to the price variable.


PROCEDURE applyTax(cost, percentTaxed)
{
    temp ← 100 + percentTaxed
    temp← temp/ 100
    cost ← cost *temp
    RETURN(cost)
}
price ← applyTax(price, 8)
This applys the 8% tax to the price determined after the discount.

Popcorn Hack 1

Given the applyTax procedure above: How would you call the procedure to get it to find the price using cost = 50, and percentTaxed = 10, and what value will it return?

#code here
cost = 50
DISPLAY applyTax(50, 10)

# return value: 55

What Are Functions?

What Are The Components of a Function?

# Defining Functions
#
# def function_name(parameter1, parameter2, etc..):
#     code here...
#
#     return return_value;

# return the value of parameter1 plus parameter2;
def add(parameter1, parameter2): # creates a function that takes in two parameters
    solution = parameter1 + parameter2; # sets solution to the sum of parameter1 and parameter2
    return solution; # return solution
    
print(add(5, 5)); # prints the return value of add(5,5)

Popcorn Hack 2:

1. Make a function that returns the difference of two numbers

# Code here

def subtract(num1, num2):
    solution = num1 - num2
    return abs(solution)


subtract(-1, 2)

3

What is a Class?

How Does a Class Work?

# Defining Classes
class person:
    def __init__(self, name, age, ): # constructor
        self.name = name;
        self.age = age;
    
    def getName(self): # method to create get name
        return self.name;
    
    def getAge(self): # method to create get age
        return self.age;
    
    def setName(self, name): # method to create set name
        self.name = name;
        
    def setAge(self, age): # method to create set age
        self.age = age;
        
    def yearOlder(self): # method to increment age by 1
        self.age += 1;
        
    def __str__(self): # method that returns a string when the object is printed
        return (f"My name is {self.name} and I am {self.age} years old.")

Person1 = person("John Doe", 15);
print(Person1)


print(Person1);

Popcorn Hack 3:

1. Create a Car class which has the attributes model, vehicle name, and price

2. Create instances of the following cars

class Car:
    def __init__(self, car, model, price): # constructer
        self.car = car
        self.model = model
        self.price = price
    def setCar(self, car):
        self.car = car
    def setCar(self, model):
        self.model = model
    def setPrice(self, price):
        self.price = price
    def getCar(self):
        return self.car
    def getModel(self):
        return self.model
    def getPrice(self):
        return self.price
    def __str__(self):
        return f"My car is a {self.model} {self.car}, priced at {self.price}"
    
car1 = Car("Honda Civic", 2018, "$13,000")
car2 = Car("Toyota Prius", 2023, "$28,000")
car3 = Car("Chevrolet Impala", 2020, "$22,000")
print(car1)
print(car2)
print(car3)

My car is a 2018 Honda Civic, priced at $13,000
My car is a 2023 Toyota Prius, priced at $28,000
My car is a 2020 Chevrolet Impala, priced at $22,000

Homework:

Assignment 1: How do you use functions?

Create a function that takes in an array as the parameter and returns the array of distinct values. DON’T USE SETS. TEST ARRAY: arr1 = [2,1,3,2,0,2,0,0,4,2,0,0,0,2,0,0,1,2,3,0,7,4,5,2,1,2,3,4,6].

arr1 = [2,1,3,2,0,2,0,0,4,2,0,0,0,2,0,0,1,2,3,0,7,4,5,2,1,2,3,4,6]

def onlyUnique(lst):
    new_lst = []
    for element in lst:
        if element not in new_lst:
            new_lst.append(element)
        else:
            continue
    return new_lst

print(onlyUnique(arr1))

[2, 1, 3, 0, 4, 7, 5, 6]

Assignment 2:

Create a student class that...

  1. Has a constructor that takes three parameters as attributes
    • email
    • name
    • grade
  3. Three getter methods to access the name, email, and grade
  4. Three setter methods to modify the name, email, and grade
  5. A to string method that returns the three instance variables in this format - "My name is {name}. My email is {email}. My grade is {grade}
  6. Create an instance of the class that corresponds with you
class Student:
    def __init__(self, email, name, grade):
        self.email = email
        self.name = name
        self.grade = grade
    def getName(self):
        return self.name
    def getEmail(self):
        return self.email
    def getGrade(self):
        return self.grade
    def setName(self, name):
        self.name = name
    def setEmail(self, email):
        self.email = email
    def setGrade(self, grade):
        self.grade = grade
    def __str__(self):
        return f"My name is {self.name}. My email is {self.email}. My grade is {self.grade}."

advik = Student(name="advik", email="funnykidland@gmail.com", grade=10)

print(advik)

My name is advik. My email is funnykidland@gmail.com. My grade is 10

Old Assignment 1(Extra credit)

# Runs fine in repl.it

import turtle

pen = turtle.Turtle()
# pen is the instance of Turtle which has methods that do certain actions

# Necessary methods:
# .forward(50) - moves the pen forward 50 units
# .right(angle) - turns the pen angle degrees right
# OR
# .left(angle) - turns the pen angle degrees left


def shape(sides):
  total = 500
  side_len = total // sides
  angle = 360 / sides
  for side in range(sides):
    pen.forward(side_len)
    pen.right(angle)


numsides = input('How many sides do yoUUUU wnat in YOUUUURRRR shape?!?!!?!: ')
shape(int(numsides))


Procedures, also known as functions or methods, are reusable blocks of code that perform specific tasks.

They enhance code organization, readability, and maintainability.

Procedures accept input parameters, execute a series of instructions, and may return a result.

Developing procedures involves defining their purpose, input parameters, and expected output.

Well-structured procedures follow the "DRY" (Don't Repeat Yourself) principle, reducing code duplication.

Parameters allow procedures to be customized for different use cases.

Naming conventions and clear documentation are essential for making procedures understandable and user-friendly.

Procedures can be grouped into libraries or modules for better code organization.

Error handling within procedures ensures robust and reliable code.

Understanding how to create, call, and manage procedures is fundamental to effective coding.

Mastery of procedural programming is a valuable skill for software development.