Write A Python Function To Calculate Percentage Between Two Numbers

Interactive Python Percentage Calculator

Use this premium calculator to find what percentage one number is of another, or calculate percentage change from a starting value to a new value. The tool also shows a visual chart and gives you production-ready Python logic you can adapt for scripts, APIs, analytics dashboards, homework, and automation projects.

Percentage Calculator

How This Tool Helps

• Mode 1: Finds what percent Number A is of Number B using the standard formula (A / B) × 100.
• Mode 2: Calculates percentage change from Number A to Number B using ((B – A) / A) × 100.
• Code-ready thinking: The same formulas shown here map directly to a clean Python function.
• Useful guardrails: Learn how to handle divide-by-zero cases and format output properly.
• Visual breakdown: The included chart helps you quickly compare the two values.

Python tip: If Number B is zero in a part-of-whole calculation, the percentage is undefined. If Number A is zero in percentage change mode, you must handle that separately because division by zero is not allowed.

Expert Guide: How to Write a Python Function to Calculate Percentage Between Two Numbers

Writing a Python function to calculate percentage between two numbers sounds simple, but there are actually a few different interpretations of the phrase. In real projects, one developer might mean, “What percentage is 25 out of 80?” Another might mean, “How much did the value grow from 80 to 100 in percentage terms?” Those are related calculations, but they are not identical. If you want to write robust, professional Python code, the first step is understanding which percentage formula fits the problem you are solving.

At its core, percentage is just a ratio expressed out of 100. Python is especially good at this kind of calculation because the syntax is clean, the operators are intuitive, and the language is widely used in data analysis, web applications, finance, automation, and scientific computing. Whether you are creating a classroom assignment, a command line script, a Flask app, or a pandas workflow, building a small reusable percentage function is one of those practical skills that pays off repeatedly.

Two Common Meanings of “Percentage Between Two Numbers”

Before you write any code, define the business meaning clearly. Most cases fall into one of these two categories:

• Part of whole percentage: What percentage is number A of number B? Formula: (A / B) × 100.
• Percentage change: How much did a value increase or decrease from A to B? Formula: ((B – A) / A) × 100.

For example, if you sold 45 units out of a target of 60, then 45 is 75% of 60. But if sales changed from 45 to 60, the percentage change is 33.33%. Both use the same two numbers, but they answer different questions. This is why naming your Python function clearly matters. A function named calculate_percentage is okay, but names like percentage_of or percentage_change are even better because they reduce ambiguity.

A Simple Python Function for Part of Whole Percentage

Let us start with the classic case. If you want to know what percent one number is of another, use this pattern:

def percentage_of(part, whole): if whole == 0: raise ValueError(“whole cannot be zero”) return (part / whole) * 100

This function is compact, readable, and easy to test. If you call percentage_of(45, 60), the result is 75.0. The guard clause is important because Python will throw a division-by-zero error if whole is zero. In production code, explicit validation is usually preferable because it makes your error handling intentional and your function easier for others to understand.

A Python Function for Percentage Change

If you want to measure growth or decline from one value to another, the formula changes:

def percentage_change(original, new_value): if original == 0: raise ValueError(“original value cannot be zero”) return ((new_value – original) / original) * 100

This version tells you whether the change is positive or negative. If the original value is 100 and the new value is 125, the result is 25.0. If the original value is 100 and the new value is 80, the result is -20.0. That sign is useful because it distinguishes increase from decrease automatically.

Best practice: Keep part-of-whole percentage and percentage change as separate functions unless you have a very good reason to combine them. Small focused functions are easier to read, test, reuse, and debug.

Formatting the Result Nicely

Raw numeric output is fine for computation, but users usually want a rounded, human-friendly result. Python makes this easy with round() or formatted strings:

result = percentage_of(45, 60) print(f”{result:.2f}%”)

This would display 75.00%. In dashboards, reports, or APIs, consistent formatting improves trust and readability. If you are returning values for later analysis, you may want to keep the unrounded float and only apply formatting in the presentation layer.

Why Input Validation Matters

Many beginner examples stop at the formula, but professional code must handle bad or unexpected input. Consider these cases:

1. The denominator is zero.
2. The input is a string instead of a number.
3. The caller passes None.
4. The result needs a specific number of decimal places.
5. Negative values are allowed, but the meaning should be documented.

You can make your function more defensive like this:

def percentage_of(part, whole): try: part = float(part) whole = float(whole) except (TypeError, ValueError): raise ValueError(“Both inputs must be numeric”) if whole == 0: raise ValueError(“whole cannot be zero”) return (part / whole) * 100

That extra logic is useful when values come from forms, files, user input, CSV imports, or external APIs. In other words, the farther your code is from a controlled notebook environment, the more valuable validation becomes.

Real World Context: Why Percentage Skills Matter

Percentages are everywhere in computing and analytics. Developers use them for conversion rates, completion ratios, storage usage, discount calculations, test coverage, CPU utilization, memory usage, portfolio returns, and machine learning evaluation. Data literacy is now expected across many roles, and percentages are one of the most common ways to summarize change and proportion.

Use Case	Typical Formula	Example
Quiz score	(correct / total) × 100	18 correct out of 20 = 90%
Sales target completion	(actual / target) × 100	45 out of 60 units = 75%
Website growth	((new – old) / old) × 100	10,000 to 12,500 visitors = 25% growth
Price discount	((old – new) / old) × 100	$80 to $60 = 25% discount

Statistics That Show Why Numeric and Coding Skills Matter

Understanding percentage calculations is not just an academic exercise. It connects directly to broader quantitative and computing skills. According to the U.S. Bureau of Labor Statistics, employment in computer and information technology occupations is projected to grow faster than the average for all occupations, reflecting ongoing demand for analytical and software skills. Meanwhile, data-centered roles routinely depend on interpreting percentage changes, ratios, and performance metrics.

Source	Statistic	Why It Matters Here
U.S. Bureau of Labor Statistics	Computer and IT occupations are projected to add hundreds of thousands of new jobs this decade.	Percentage calculations are routine in software, analytics, and business reporting.
National Center for Education Statistics	Quantitative literacy remains a central component of modern education outcomes.	Percentage reasoning is a foundational quantitative skill.
U.S. Census Bureau	Population, income, and business reports frequently present change in percentage terms.	Being able to compute and interpret percentages is essential for working with public data.

Should You Return a Float, String, or Rounded Value?

This depends on where the function will be used. If the result is going into another calculation, return a numeric value such as a float. If the value is meant for a user interface, you can format it into a string with a percent sign. A clean pattern is to keep the calculation function numeric and create a separate display function when needed. That way your core logic remains reusable across applications.

def percentage_of(part, whole): if whole == 0: raise ValueError(“whole cannot be zero”) return (part / whole) * 100 def format_percentage(value, decimals=2): return f”{value:.{decimals}f}%”

Using Type Hints for Cleaner Python

Type hints are a good addition if you want more maintainable code, especially in larger codebases or team environments:

def percentage_of(part: float, whole: float) -> float: if whole == 0: raise ValueError(“whole cannot be zero”) return (part / whole) * 100

Type hints do not enforce types at runtime by themselves, but they improve editor support, readability, and static analysis. For libraries, APIs, and long-lived code, this can be very helpful.

How to Test Your Percentage Function

Even a small function deserves tests. Unit tests make sure edge cases do not break silently later.

def test_percentage_of(): assert percentage_of(50, 200) == 25.0 assert percentage_of(3, 12) == 25.0 def test_percentage_change(): assert percentage_change(100, 125) == 25.0 assert percentage_change(100, 80) == -20.0

You should also test invalid cases, especially zero denominators and bad input types. This is one of the easiest ways to build coding discipline early.

Common Mistakes Beginners Make

• Using the wrong denominator in the formula.
• Confusing part-of-whole percentage with percentage change.
• Forgetting to multiply by 100.
• Not handling division by zero.
• Returning a formatted string when a numeric result is needed later.
• Rounding too early and losing precision for downstream calculations.

One of the easiest ways to avoid these mistakes is to write a short docstring that explains exactly what the function returns. Clear naming plus a docstring can prevent hours of debugging in larger projects.

A More Flexible Combined Function

If you truly want a single function that supports multiple percentage modes, you can do that too:

def calculate_percentage(a, b, mode=”part_of_whole”): a = float(a) b = float(b) if mode == “part_of_whole”: if b == 0: raise ValueError(“b cannot be zero”) return (a / b) * 100 if mode == “percent_change”: if a == 0: raise ValueError(“a cannot be zero”) return ((b – a) / a) * 100 raise ValueError(“Invalid mode”)

This approach is convenient for small tools and interfaces, but in many codebases separate functions are still cleaner. Use whichever style fits your project and team standards.

Helpful Authoritative Resources

If you want to strengthen both your coding and quantitative reasoning, these authoritative resources are worth reviewing:

• U.S. Bureau of Labor Statistics: Computer and Information Technology Occupations
• National Center for Education Statistics
• U.S. Census Bureau Data and Statistics

Final Takeaway

If you need to write a Python function to calculate percentage between two numbers, first decide whether you mean proportion or change. For proportion, use (part / whole) × 100. For change, use ((new – original) / original) × 100. Then add validation for zero denominators, keep the return value numeric when possible, and format the result only when presenting it to users. Those few decisions turn a basic classroom solution into reliable, professional code.

The calculator above can help you verify your logic instantly before you code it into Python. Once you understand the formulas and edge cases, the implementation becomes straightforward. Good Python functions are not just short. They are correct, readable, resilient, and clear about what they compute.