How to Get the First Digit of a Number in Python
If I give you the number 54321, what’s the first digit? Obviously, it’s 5. But what if I give you -0.00789? The first digit is actually 7. Here’s what’s wild – this simple concept can catch criminals, verify scientific research, and spot fake tax returns.
When people make up numbers, they don’t follow the same patterns that occur naturally. Real data has specific fingerprints. Fake data looks different. Learning to extract first digits lets you detect these differences.
I’ll show you four different ways to get that first digit in Python. Each method solves different problems. By the end, you’ll know which one to use when.

Why This Actually Matters
Next time you’re at the grocery store, look at the prices. Notice how many start with 1, 2, or 3? Very few start with 8 or 9. This isn’t random – it’s math.
In 1938, a physicist named Frank Benford was bored and started counting first digits in newspaper data, street addresses, population numbers, anything he could find. He discovered something crazy: 30% of real-world numbers start with 1, but only 5% start with 9.
Here’s the kicker – when people make up numbers, they don’t follow this pattern. They distribute digits more evenly because that “feels” more random. But nature isn’t evenly distributed. This difference is how we catch liars.
Real people using this right now:
- Forensic accountants: Catch employees faking expense reports
- Research reviewers: Spot scientists who fabricated their data
- IRS agents: Flag suspicious tax returns for audit
- Insurance investigators: Find inflated damage claims
- Election monitors: Detect vote count manipulation
Learning first digit extraction connects you to this fraud detection pipeline used in data preprocessing.
What Counts as a “First Digit”
This sounds obvious until you hit edge cases. Let me clear up the confusion with examples.
The first digit is the leftmost non-zero digit. Skip minus signs, skip decimal points, skip leading zeros. Just find the first digit that isn’t zero.
Here’s what you’ll encounter:
Basic Examples:
- 4567 → First digit is 4 (straightforward case)
- -9823 → First digit is 9 (ignore the minus sign)
- 0.009 → First digit is 9 (skip the leading zeros)
- 0.56789 → First digit is 5 (first non-zero after decimal)
- -0.00789 → First digit is 7 (ignore minus, skip zeros)
- 1000000 → First digit is 1 (the leading digit)
- 0 → First digit is 0 (special exception)
The Rules That Matter
Negative Numbers: The minus sign just shows direction. We care about magnitude, not sign. So -987 and +987 both have first digit 9. We’re asking “how big is this number?” not “which way does it point?” This aligns with how Python’s number types work.
Decimal Numbers: Leading zeros are placeholders, not values. In 0.00456, those zeros are just telling you the decimal point location. The 4 is the first actual value. You see this constantly in scientific data – measurements like 0.0000123 where the first digit is 1.
Zero Exception: Zero is the only number where the first digit is zero. Every other number has a first digit from 1-9. Zero breaks the rule because zero literally means “no value” – so its first digit is also “no value.”
Common Misconceptions:
- Wrong: “The first digit of 0.123 is 0” – Those zeros are just positioning
- Wrong: “Negative signs affect the first digit” – We focus on magnitude
- Wrong: “1.000 has multiple first digits” – Only the 1 counts as significant
Mastering these concepts builds confidence for handling edge cases in Python applications.
Method 1: String Conversion
Turn the number into text, then read it character by character until you hit the first non-zero digit. Simple as that.
Why does this work? Because you already know how to read. When you see 54321 written down, your brain automatically identifies “5” as the first character. We’re just teaching Python to do what your brain does naturally.

The Process
Think about reading a house address: “0001234 Main Street.” Your brain automatically skips the leading zeros and focuses on “1234.” You don’t consciously think about it – it just happens.
Here’s how we code this natural process:
- Convert to text: Turn 12345 into “12345”
- Scan left to right: Look at each character individually
- Skip non-digits: Ignore minus signs and decimal points
- Skip zeros: Keep going until you find a non-zero digit
- Return the result: Convert that character back to an integer
This approach handles any number type because string conversion is universal in Python. Works with integers, floats, complex numbers, whatever.
def get_first_digit_string(num):
"""
Get the first digit using string conversion method.
This method works with any type of number.
"""
# Convert to string to examine each character
str_num = str(num)
# Go through each character
for char in str_num:
# Check if it's a digit and not zero
if char.isdigit() and char != '0':
return int(char)
# If we reach here, the number was 0
return 0
# Test examples
print(get_first_digit_string(12345)) # Output: 1
print(get_first_digit_string(-9876)) # Output: 9
print(get_first_digit_string(0.00567)) # Output: 5
Breaking Down the Code
Line 6: str(num) converts any number to text. 12345 becomes “12345”. Now instead of one number, we have five separate characters that we can examine individually.
Line 9: The for loop goes through each character. It’s like pointing your finger at each digit as you read from left to right.
Line 11: Two checks happen here. First: char.isdigit() asks “is this actually a number?” (returns False for letters or symbols). Second: char != ‘0’ asks “is this something other than zero?” We need both checks to find the first meaningful digit.
Line 12: Found our target! int(char) converts the text digit back to a number. The character “5” becomes the integer 5. return immediately exits with our answer.
Line 15: Safety net for when the input is just 0. Since zero’s first digit is zero, we need this special case.
Why This Works
Python temporarily stores the number as text in memory. Uses minimal resources, and the simplicity makes it bulletproof for any number type you encounter.
Try It Yourself
Advantages and Disadvantages
- Very easy to understand and write
- Works with any number type
- Handles negative numbers automatically
- Handles decimal numbers automatically
- Perfect for beginners
- Slightly slower for very large numbers
- Creates a string in memory
- Not as elegant as mathematical methods
- Some programmers consider it less professional
This method works well when you are learning Python data types and need a reliable solution.
Method 2: Division Method
Keep dividing by 10 until you’re left with a single digit. That’s your first digit.
Why this works: dividing by 10 chops off the rightmost digit. 12345 ÷ 10 = 1234. Keep going until you can’t divide anymore. Whatever’s left is your answer.

How It Works
Take 12345. When you divide by 10, you knock off the last digit:
Step by Step:
- 12345 ÷ 10 = 1234 (bye bye, 5)
- 1234 ÷ 10 = 123 (bye bye, 4)
- 123 ÷ 10 = 12 (bye bye, 3)
- 12 ÷ 10 = 1 (bye bye, 2)
- 1 is less than 10, so we stop
Each division moves all digits one position to the right. The rightmost digit gets chopped off completely.
Integer vs Regular Division
Python has two division operators. Regular division (/) keeps decimals: 12345 / 10 = 1234.5. Integer division (//) tosses the decimal: 12345 // 10 = 1234.
We need integer division because we want to completely eliminate digits, not turn them into decimals. This approach works great with Python’s integer handling.
def get_first_digit_division(num):
"""
Get the first digit using while loop and division.
This method uses pure mathematics.
"""
# Remove negative sign and convert to integer
num = abs(int(num))
# Special case: if number is 0
if num == 0:
return 0
# Keep dividing by 10 until single digit
while num >= 10:
num = num // 10 # Integer division
return num
# Test examples
print(get_first_digit_division(12345)) # Output: 1
print(get_first_digit_division(-9876)) # Output: 9
print(get_first_digit_division(567.89)) # Output: 5
Code Explanation
Line 7: We use abs() to remove the negative sign and int() to remove decimal parts. This gives us a positive whole number.
Line 10-11: We handle the special case where the input is 0.
Line 14: We start a while loop that continues as long as the number has multiple digits (greater than or equal to 10).
Line 15: We use integer division (//) to remove the last digit. For 12345 // 10, we get 1234.
Line 17: When the loop ends, we have a single digit, which is our first digit.
Watch the Division Process
When to Use This Method
- Integer numbers
- Performance-critical applications
- When you want to avoid string operations
- Mathematical purists who prefer numeric operations
- Loses decimal precision
- Not ideal for numbers like 0.005
- Requires type conversion for floats
This method demonstrates solid understanding of mathematical operations and is often used in data science interview questions.
Method 3: Logarithmic Approach
This sophisticated method uses the mathematical relationship between logarithms and digit counting. Instead of manually counting digits or iterating through them, we use logarithmic properties to calculate the exact position of the first digit.
Logarithms answer the question: “To what power must I raise 10 to get this number?” This relationship directly tells us how many digits a number contains, allowing us to extract the first digit with surgical precision.

The Logarithmic Foundation
Every positive number can be expressed as 10 raised to some power. Understanding this relationship unlocks the logarithmic method:
Power of 10 Examples:
- 100 = 10²: log₁₀(100) = 2, so 100 has 3 digits
- 1000 = 10³: log₁₀(1000) = 3, so 1000 has 4 digits
- 12345: log₁₀(12345) ≈ 4.09, so 12345 has 5 digits
The Mathematical Insight
Here’s the crucial insight: if a number has n digits, then log₁₀(number) falls between n-1 and n. The floor of this logarithm gives us exactly n-1, which tells us the highest power of 10 we need to divide by.
For example, with 12345:
- Step 1: log₁₀(12345) ≈ 4.09
- Step 2: floor(4.09) = 4
- Step 3: 12345 ÷ 10⁴ = 12345 ÷ 10000 = 1.2345
- Step 4: floor(1.2345) = 1
Why This Works
The logarithmic method exploits the structure of our decimal system. Every number can be written as: first_digit × 10^(digits-1) + remaining_value. By using logarithms to find the exponent, we can reverse-engineer the first digit.
This mathematical elegance makes it a favorite in performance-critical Python applications where computational efficiency matters.
import math
def get_first_digit_log(num):
"""
Get the first digit using logarithms.
This method is mathematically elegant.
"""
# Remove negative sign
num = abs(num)
# Special case: if number is 0
if num == 0:
return 0
# Calculate number of digits using log10
digits = int(math.log10(num))
# Extract first digit
first_digit = int(num // (10 ** digits))
return first_digit
# Test examples
print(get_first_digit_log(12345)) # Output: 1
print(get_first_digit_log(9876)) # Output: 9
print(get_first_digit_log(567.89)) # Output: 5
Understanding Each Step
Line 1: We import the math module to use log10 function.
Line 9: We remove the negative sign using abs().
Line 12-13: We handle the special case of zero.
Line 16: We calculate how many digits the number has. The int() function rounds down to get the power of 10.
Line 19: We divide the number by 10 raised to the power of (digits). This moves the first digit to the ones place.
See Logarithms in Action
Performance and Use Cases
- Mathematically elegant and professional
- Very fast for large numbers
- Constant time complexity
- Impresses in technical interviews
- Uses minimal memory
This approach showcases advanced mathematical problem-solving and demonstrates understanding of Python’s type functions and mathematical libraries.
Method 4: Float Normalization
This method specializes in handling decimal numbers. We multiply tiny decimals until they become larger than 1, then extract the first digit. This method handles numbers like 0.000578 perfectly.
The Normalization Process
Here is how we handle the decimal 0.000578:
- Start with 0.000578
- Multiply by 10: 0.00578 (still less than 1)
- Multiply by 10: 0.0578 (still less than 1)
- Multiply by 10: 0.578 (still less than 1)
- Multiply by 10: 5.78 (now it is greater than 1)
- Take the first character: “5”
def get_first_digit_float(num):
"""
Get the first digit by normalizing floats.
Perfect for tiny decimal numbers.
"""
# Remove negative sign
num = abs(num)
# Special case: if number is 0
if num == 0:
return 0
# Keep multiplying by 10 until number is >= 1
while num < 1:
num *= 10
# Get first digit using string method
return int(str(num)[0])
# Test examples
print(get_first_digit_float(0.000578)) # Output: 5
print(get_first_digit_float(-0.789)) # Output: 7
print(get_first_digit_float(12345)) # Output: 1
Code Breakdown
Line 7: We remove any negative sign to work with positive numbers only.
Line 10-11: We handle the special case where the input is zero.
Line 14: We start a while loop that continues as long as the number is less than 1.
Line 15: We multiply by 10 to make the number bigger. This shifts the decimal point right.
Line 18: Once the number is 1 or larger, we convert it to a string and take the first character.
Watch Normalization Process
When This Method Shines
- Scientific data with very small decimals
- Financial calculations with varying decimal places
- Numbers in scientific notation
- Mixed datasets with both large and tiny numbers
This method is essential in data preprocessing tasks where decimal precision varies widely across your dataset.
Comparing All Four Methods
Now that you know all four methods, let me help you choose the right one for your needs. Each method has strengths and weaknesses.
Method | Integers | Floats | Negatives | Ease of Use | Performance | Best For |
---|---|---|---|---|---|---|
String Conversion | Excellent | Excellent | Excellent | Very Easy | Good | Beginners |
Division Loop | Excellent | Limited | Excellent | Easy | Excellent | Integer work |
Logarithms | Excellent | Limited | Excellent | Moderate | Excellent | Performance |
Float Normalization | Excellent | Excellent | Excellent | Easy | Good | Scientific data |
Decision Guide
For learning Python: Start with the string conversion method. It is the most straightforward and works with all number types.
For performance-critical applications: Use the logarithmic method or division loop. These avoid string operations and run faster.
For scientific computing: Use float normalization when working with very small decimal numbers.
For job interviews: Know all four methods. Interviewers appreciate seeing multiple approaches to the same problem.
Compare All Methods
Handling Edge Cases
Professional programmers always consider unusual inputs that might break their code. Let me show you how to build robust functions that handle any input gracefully.
Common Edge Cases
- Zero: The first digit of 0 is 0
- Negative zero: Python has -0.0 which exists but equals 0
- Very large numbers: Numbers like 10²³
- Very tiny numbers: Numbers like 1e-100
- Invalid inputs: Text like “hello” instead of numbers
- None values: When no input is provided
import math
def get_first_digit_robust(num):
"""
A bulletproof function that handles all edge cases.
Returns None for invalid inputs.
"""
try:
# Handle None input
if num is None:
return None
# Try to convert to float
num = float(num)
# Handle special float values
if math.isnan(num) or math.isinf(num):
return None
# Handle zero (including negative zero)
if num == 0:
return 0
# Use string method for reliability
str_num = str(abs(num))
# Find first non-zero digit
for char in str_num:
if char.isdigit() and char != '0':
return int(char)
return None
except (ValueError, TypeError, OverflowError):
return None
# Test with edge cases
test_cases = [12345, -0.789, 0, "456", None, "hello"]
for test in test_cases:
result = get_first_digit_robust(test)
print(f"Input: {test} → Result: {result}")
Test Edge Cases
Proper edge case handling separates professional developers from beginners. This skill is crucial for building reliable Python applications.
Real-World Applications
The power of first digit analysis extends far beyond academic exercises. From catching white-collar criminals to validating scientific discoveries, this mathematical technique shapes critical decisions in boardrooms, courtrooms, and research laboratories worldwide.

Criminal Investigation: The Mathematics of Deception
Frank Benford’s 1938 discovery revolutionized fraud detection. He noticed that in naturally occurring datasets, smaller digits appear as first digits more frequently than larger ones. This isn’t coincidence – it’s a fundamental property of how numbers distribute in the real world.
When criminals fabricate financial records, they unconsciously create patterns that violate Benford’s Law. Human psychology leads people to distribute fake numbers more evenly than nature does. This mathematical signature becomes evidence in legal proceedings.
Notable Criminal Cases:
- Enron Scandal (2001): Forensic accountants used Benford’s Law analysis to identify manipulated financial statements
- Greek Statistics (2012): EU investigators applied first digit analysis to detect fabricated economic data during the debt crisis
- Insurance Fraud: Companies routinely screen claim amounts using this technique, saving millions in fraudulent payouts
Scientific Validation and Research Integrity
Research institutions employ first digit analysis to verify experimental data authenticity. When scientists submit fabricated measurements, the artificial numbers often fail Benford’s Law tests. This mathematical scrutiny protects scientific integrity and public trust.
Climate researchers use this technique to validate temperature records from weather stations. Population biologists apply it to verify species count data. Even astronomers check telescope measurements using first digit patterns.
Business Intelligence and Market Analysis
Corporate analysts leverage first digit patterns to assess data quality before making strategic decisions. Stock market data, sales figures, and customer analytics all undergo this mathematical verification process.
Supply chain managers detect inventory discrepancies using these patterns. Marketing teams validate survey responses and demographic data. Financial planners screen investment opportunities by analyzing historical performance numbers.
This analysis becomes particularly valuable in large-scale data processing environments where manual verification proves impossible.
from collections import Counter
def analyze_benford_law(numbers):
"""
Analyze if a dataset follows Benford's Law.
Returns percentage for each first digit.
"""
# Extract first digits
first_digits = []
for num in numbers:
digit = get_first_digit_robust(num)
if digit and digit != 0:
first_digits.append(digit)
# Count frequency
counter = Counter(first_digits)
total = len(first_digits)
# Benford's Law expected percentages
benford_expected = [30.1, 17.6, 12.5, 9.7, 7.9, 6.7, 5.8, 5.1, 4.6]
print("Digit | Actual% | Expected% | Status")
print("-" * 40)
for digit in range(1, 10):
actual = (counter[digit] / total) * 100 if total > 0 else 0
expected = benford_expected[digit - 1]
difference = abs(actual - expected)
if difference < 5:
status = "Normal"
elif difference < 10:
status = "Suspicious"
else:
status = "Very Suspicious"
print(f" {digit} | {actual:5.1f}% | {expected:5.1f}% | {status}")
# Example usage
legitimate_expenses = [1234, 987, 2456, 1789, 3456, 1234, 2345]
analyze_benford_law(legitimate_expenses)
Other Real-World Uses
Financial Services: Banks analyze expense reports and tax returns to find fraud patterns.
Scientific Research: Researchers check if their data follows natural distributions expected in real-world measurements.
Game Development: Developers ensure random number generators create fair distributions in games.
Data Science: Analysts use first digit analysis in feature engineering for machine learning projects.
Test Benford’s Law
These applications show why first digit extraction is valuable in data analysis with NumPy and Pandas.
Interactive Quiz
Test your understanding with this quick quiz. Choose the best answer for each question.
Frequently Asked Questions
External Resources
Learn More About Python Mathematics
- Official Python Math Module Documentation – Complete reference for mathematical functions
- GeeksforGeeks: Find First and Last Digits – Additional algorithms and approaches
- Extract Digits from Python Strings – String manipulation techniques
Summary and Next Steps
You now possess four distinct approaches to first digit extraction, each with specific strengths that serve different scenarios. This knowledge equips you to handle diverse programming challenges while understanding the mathematical principles underlying each solution.
Method Selection Framework
Choose your approach based on these practical considerations:
Decision Matrix:
- Learning Phase: String Conversion provides clear logic flow and handles all input types reliably
- Performance Requirements: Logarithmic method offers constant-time complexity for large datasets
- Integer-Heavy Applications: Division Loop avoids string operations while maintaining mathematical elegance
- Scientific Computing: Float Normalization handles extreme decimal precision requirements
Professional Development Path
Mastering these techniques opens several career advancement opportunities:
- Financial Technology: Build fraud detection systems using Benford’s Law implementation
- Data Science: Apply first digit analysis for dataset validation and quality assurance
- Scientific Computing: Develop measurement verification tools for research institutions
- Business Intelligence: Create data integrity checks for corporate analytics platforms
Continue Learning
Now that you understand first digit extraction, explore these related topics:
- Learn more about Python data types to handle numbers better
- Study variables and constants for better code organization
- Master error handling to build robust applications
- Explore data analysis with NumPy and Pandas
- Practice with data science interview questions
Build Real Projects
Apply these skills in practical projects:
- Create a fraud detection system using Benford’s Law
- Build a number analysis tool for financial data
- Develop data validation checks for scientific datasets
- Design a random number quality tester
Understanding first digit extraction opens doors to advanced topics in data science, finance, and software development. Keep practicing and building projects to strengthen your Python skills.
Leave a Reply