1/4 Mile Calculator using PyQt5 in Python

What Is a 1/4 Mile Calculator?

A 1/4 mile calculator helps to estimate how long it will take for a vehicle to cover a quarter-mile (about 400 meters) based on speed. This is a common way to measure a car's acceleration and performance in drag racing.

To make this estimation, we will use the following basic formula:

ET = (weight / horsepower) ** (1/3) * 5.825

In this formula:

• ET stands for Estimated Time in seconds
• Weight is the car's weight in pounds
• Horsepower is the engine power in HP

Creating a 1/4 Mile Calculator Using PyQt5 in Python

PyQt5 is a Python library that helps you create desktop applications with graphical interfaces. It provides components like buttons, labels, textboxes, and more.

To install PyQt5 in your system (if it is not present), use the following command:

pip install PyQt5

To build a 1/4-mile calculator using PyQt5 in Python, we will:

• Design a simple window with two input fields: one for weight and the other for horsepower.
• Add a button that performs the calculation.
• Display the estimated 1/4-mile time instantly using a racing formula.

When the user enters values and clicks the button, the calculator will display the 1/4-mile time based on the formula.

Step-by-Step Implementation

Following are the step-by-step instructions to build a 1/4-mile time calculator in Python using PyQt5

Step 1: Import PyQt5 and Set Up the Window

We start by importing the required PyQt5 modules and creating a basic application window.

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout

These imports include:

• QApplication to start the app
• QWidget for the main window
• QLabel for labels
• QLineEdit for user input
• QPushButton for the action button
• QVBoxLayout for arranging widgets vertically

Step 2: Define the Main Calculator Class

We define a class QuarterMileCalculator that sets up the interface and connects the logic to the button.

class QuarterMileCalculator(QWidget):
   def __init__(self):
      super().__init__()

      # Set window title
      self.setWindowTitle("1/4 Mile Time Calculator")

      # Create UI elements
      self.weight_label = QLabel("Enter Car Weight (lbs):")
      self.weight_input = QLineEdit()

      self.hp_label = QLabel("Enter Horsepower (HP):")
      self.hp_input = QLineEdit()

      self.result_label = QLabel("")
      self.calculate_button = QPushButton("Calculate Time")

      # Connect button to function
      self.calculate_button.clicked.connect(self.calculate_time)

      # Layout
      layout = QVBoxLayout()
      layout.addWidget(self.weight_label)
      layout.addWidget(self.weight_input)
      layout.addWidget(self.hp_label)
      layout.addWidget(self.hp_input)
      layout.addWidget(self.calculate_button)
      layout.addWidget(self.result_label)

      self.setLayout(layout)

This step sets up:

• Two labels and inputs for weight and horsepower
• A button to perform the calculation
• A label to show the result
• A vertical layout for arranging widgets neatly

Step 3: Calculating the 1/4-Mile

We use the formula from earlier:

ET = (weight / horsepower) ** (1/3) * 5.825

This formula estimates the 1/4-mile time based on physics models of power-to-weight ratio. Define a method where we will calculate the 1/4^th mile using the above-discussed formula:

def calculate_time(self):
   try:
      weight = float(self.weight_input.text())
      horsepower = float(self.hp_input.text())

      if weight <= 0 or horsepower <= 0:
         self.result_label.setText("Both values must be greater than 0.")
         return

      et = (weight / horsepower) ** (1/3) * 5.825
      self.result_label.setText(f"Estimated 1/4 mile time: {et:.2f} seconds")

   except ValueError:
      self.result_label.setText("Please enter valid numeric values.")

This method does the following:

• Reads input values from the text boxes
• Applies the formula only if both values are valid and positive
• Displays the result rounded to 2 decimal places

Step 4: Run the Application

Finally, set up the main function to launch the window.

if __name__ == "__main__":
   app = QApplication(sys.argv)
   window = QuarterMileCalculator()
   window.show()
   sys.exit(app.exec_())

This snippet:

• Creates the application object
• Initializes our calculator window
• Enters the event loop to wait for user interaction

Complete Example

Here is the complete code to create a 1/4 mile calculator using PyQt5 in Python:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout

# Define the main calculator class inheriting from QWidget
class QuarterMileCalculator(QWidget):
   def __init__(self):
      super().__init__()

      # Set the title of the window
      self.setWindowTitle("1/4 Mile Time Calculator")

      # Create label and input for car weight
      self.weight_label = QLabel("Enter Car Weight (lbs):")
      self.weight_input = QLineEdit()

      # Create label and input for horsepower
      self.hp_label = QLabel("Enter Horsepower (HP):")
      self.hp_input = QLineEdit()

      # Label to display result
      self.result_label = QLabel("")

      # Button to trigger calculation
      self.calculate_button = QPushButton("Calculate Time")

      # Connect button click to the calculation method
      self.calculate_button.clicked.connect(self.calculate_time)

      # Arrange all widgets using vertical layout
      layout = QVBoxLayout()
      layout.addWidget(self.weight_label)
      layout.addWidget(self.weight_input)
      layout.addWidget(self.hp_label)
      layout.addWidget(self.hp_input)
      layout.addWidget(self.calculate_button)
      layout.addWidget(self.result_label)

      # Set the layout to the main window
      self.setLayout(layout)

   # Method to calculate 1/4 mile time
   def calculate_time(self):
      try:
         # Get input values and convert to float
         weight = float(self.weight_input.text())
         horsepower = float(self.hp_input.text())

         # Check for valid positive inputs
         if weight <= 0 or horsepower <= 0:
            self.result_label.setText("Both values must be greater than 0.")
            return

         # Apply the estimation formula
         et = (weight / horsepower) ** (1/3) * 5.825

         # Display the result
         self.result_label.setText(f"Estimated 1/4 mile time: {et:.2f} seconds")

      except ValueError:
         # Handle invalid (non-numeric) input
         self.result_label.setText("Please enter valid numeric values.")

# Run the application
if __name__ == "__main__":
   app = QApplication(sys.argv)  # Create application instance
   window = QuarterMileCalculator() # Create calculator window
   window.show()   # Show the window
   sys.exit(app.exec_())  # Start the event loop

When you run the app, you get to see the following output:

Enter 3500 in the "Enter Car Weight (lbs)" field.
Enter 400 in the "Enter Horsepower (HP)" field.
Click "Calculate Time".
Estimated 1/4 mile time: 13.23 seconds

It is as shown in the GIF below:

Conclusion

In this article, we built a simple 1/4 mile time calculator using PyQt5 in Python. The app takes weight and horsepower as inputs, applies a known racing formula, and shows the estimated time to cover a 1/4 mile.