write a program of a main module and three other modules.
The owners of the Super Supermarket would like to have a program that computes the monthly gross pay of their employees as well as the employee’s net pay. The input for this program is an employee ID number, hourly rate of pay, and the number of regular and overtime hours worked. Gross pay is the sum of the wages earned from regular hours and overtime hours; overtime is paid at 1.5 times the regular rate. Net pay is gross pay minus deductions. Assume that deductions are taken for tax withholding (30 percent of gross pay) and parking ($10 per month). You will need the following variables:
EmployeeID (a String) HourlyRate (a Float) RegHours (a Float)
GrossPay (a Float) Tax (a Float) Parking (a Float)
OvertimeHours (a Float) NetPay (a Float)
You will need the following formulas:
GrossPay = RegularHours * HourlyRate + OvertimeHours * (HourlyRate * 1.5)
NetPay = GrossPay – (GrossPay * Tax) – Parking
Here's an example code with a main module and three other modules for computing the monthly gross pay and net pay for employees in a supermarket:
**Module 1: main_module.py**
```python
import employee_module
import payroll_module
def main():
employee_id = input("Enter employee ID: ")
hourly_rate = float(input("Enter hourly rate of pay: "))
regular_hours = float(input("Enter number of regular hours worked: "))
overtime_hours = float(input("Enter number of overtime hours worked: "))
gross_pay = payroll_module.calculate_gross_pay(hourly_rate, regular_hours, overtime_hours)
deductions = payroll_module.calculate_deductions(gross_pay)
net_pay = payroll_module.calculate_net_pay(gross_pay, deductions)
print("Employee ID:", employee_id)
print("Gross Pay: $", format(gross_pay, ".2f"))
print("Deductions: $", format(deductions, ".2f"))
print("Net Pay: $", format(net_pay, ".2f"))
main()
```
**Module 2: employee_module.py**
```python
def calculate_gross_pay(hourly_rate, regular_hours, overtime_hours):
regular_wages = regular_hours * hourly_rate
overtime_wages = overtime_hours * (hourly_rate * 1.5)
gross_pay = regular_wages + overtime_wages
return gross_pay
```
**Module 3: payroll_module.py**
```python
TAX_RATE = 0.3
PARKING_FEE = 10
def calculate_deductions(gross_pay):
tax = gross_pay * TAX_RATE
deductions = tax + PARKING_FEE
return deductions
def calculate_net_pay(gross_pay, deductions):
net_pay = gross_pay - deductions
return net_pay
```
In this program, the `main_module` takes user input for employee details and calls functions from `employee_module` and `payroll_module` to calculate the gross pay, deductions, and net pay. The `employee_module` module calculates the gross pay based on regular and overtime hours worked, while the `payroll_module` module calculates deductions (taxes and parking fee) and net pay.
To write a program with a main module and three other modules to calculate the monthly gross pay and net pay of employees, you can follow these steps:
1. Create a Python file called "main.py" and open it in a text editor.
2. In the main module, import the three other modules you will create separately for employee data, calculation, and output.
3. Create a function in the main module called "main()" to handle the program logic.
4. Inside the "main()" function, call the functions from the other modules to gather employee data, calculate gross pay and net pay, and display the results.
5. Save and close the "main.py" file.
Now, let's create the other three modules:
1. Create a Python file called "employee.py" to handle employee data.
2. In the "employee.py" module, define a function called "get_employee_data()" to collect employee information from the user. This function should prompt the user for the employee ID, hourly rate of pay, and the number of regular and overtime hours worked. It should return these values as a tuple.
3. Save and close the "employee.py" file.
2. Create a Python file called "calculation.py" to handle the calculation of gross pay and net pay.
3. In the "calculation.py" module, define a function called "calculate_pay(employee_data)" that takes the employee data as input. Inside this function, extract the necessary values from the employee data tuple and use the formulas provided to calculate the gross pay and net pay. Return these values as a tuple.
4. Save and close the "calculation.py" file.
3. Create a Python file called "output.py" to handle the display of results.
4. In the "output.py" module, define a function called "display_results(gross_pay, net_pay)" that takes the gross pay and net pay values as input. Inside this function, format and display the results to the user.
5. Save and close the "output.py" file.
Here's an example implementation of the main module:
```python
# main.py
import employee
import calculation
import output
def main():
# Gather employee data
employee_data = employee.get_employee_data()
# Calculate gross pay and net pay
gross_pay, net_pay = calculation.calculate_pay(employee_data)
# Display results
output.display_results(gross_pay, net_pay)
if __name__ == "__main__":
main()
```
You can now compile and run the "main.py" file, and it will prompt the user for employee data, calculate the gross pay and net pay, and display the results accordingly.