📘 Working with Numbers: int, float, complex

🎯 Introduction

Welcome to this exciting tutorial on working with numbers in Python! 🎉 In this guide, we’ll explore the magical world of integers, floats, and complex numbers.

You’ll discover how Python’s number types can transform your programming experience. Whether you’re building financial applications 💰, scientific calculations 🔬, or games 🎮, understanding numbers is essential for writing powerful Python code.

By the end of this tutorial, you’ll feel confident working with all types of numbers in your own projects! Let’s dive in! 🏊‍♂️

📚 Understanding Numbers in Python

🤔 What are Python’s Number Types?

Python’s number types are like different tools in a toolbox 🧰. Think of them as specialized instruments: integers for counting whole things (like people 👥), floats for measuring (like temperature 🌡️), and complex numbers for advanced math (like electrical engineering ⚡).

In Python terms, we have three main numeric types. This means you can:

✨ Count and calculate with whole numbers (int)
🚀 Work with decimals and fractions (float)
🛡️ Handle advanced mathematical operations (complex)

💡 Why Different Number Types?

Here’s why Python offers different number types:

Precision Matters 🎯: Different calculations need different precision
Memory Efficiency 💻: Use only what you need
Mathematical Accuracy 📖: Some operations require specific types
Real-world Modeling 🔧: Match the type to your data

Real-world example: Imagine building a shopping cart 🛒. You’d use integers for item quantities (can’t buy 2.5 shirts!), floats for prices ($19.99), and maybe complex numbers for advanced analytics.

🔧 Basic Syntax and Usage

📝 Working with Integers

Let’s start with the basics:

# 👋 Hello, integers!
age = 25  # 🎂 Your age in years
items_in_cart = 3  # 🛒 Number of items
score = 1000  # 🎮 Game score

# 🎨 Integer operations
total_items = items_in_cart + 5  # ➕ Addition
remaining_lives = 3 - 1  # ➖ Subtraction
double_score = score * 2  # ✖️ Multiplication
teams = 20 // 4  # ➗ Floor division (5 teams)

print(f"You have {remaining_lives} lives left! 💚")

💡 Explanation: Notice how integers are perfect for counting discrete things! No decimals needed.

🎯 Working with Floats

Here’s how to work with decimal numbers:

# 🏗️ Float examples
price = 19.99  # 💰 Product price
temperature = 98.6  # 🌡️ Body temperature
pi = 3.14159  # 🥧 Mathematical constant

# 🎨 Float operations
total_cost = price * 3  # 59.97
celsius = (temperature - 32) * 5/9  # 37.0
circle_area = pi * (5 ** 2)  # 78.54 (radius = 5)

# 🔄 Mixing integers and floats
discount = price * 0.2  # 20% off = 3.998
final_price = price - discount  # 15.992

print(f"Final price: ${final_price:.2f} 💸")  # Rounds to 2 decimals

🌟 Working with Complex Numbers

For the mathematically adventurous:

# 🚀 Complex numbers (real + imaginary)
z1 = 3 + 4j  # 🎯 3 is real, 4j is imaginary
z2 = complex(2, -1)  # 🎨 Another way to create: 2-1j

# 🔧 Complex operations
sum_z = z1 + z2  # (5+3j)
product = z1 * z2  # (10+5j)

# 📊 Accessing parts
real_part = z1.real  # 3.0
imaginary_part = z1.imag  # 4.0
magnitude = abs(z1)  # 5.0 (distance from origin)

print(f"Complex magic: {z1} has magnitude {magnitude} ✨")

💡 Practical Examples

🛒 Example 1: Smart Shopping Calculator

Let’s build a real shopping calculator:

# 🛍️ Shopping calculator with different number types
class SmartCart:
    def __init__(self):
        self.items = []  # 📦 List of items
        self.tax_rate = 0.08  # 💰 8% tax (float)
        
    def add_item(self, name, quantity, price):
        # 🎯 Quantity must be integer, price can be float
        if not isinstance(quantity, int) or quantity < 1:
            print(f"❌ Can't add {quantity} {name}s!")
            return
            
        item = {
            'name': name,
            'quantity': quantity,  # 🔢 Integer
            'price': price,  # 💵 Float
            'emoji': self._get_emoji(name)
        }
        self.items.append(item)
        print(f"✅ Added {quantity} {item['emoji']} {name}(s) @ ${price:.2f} each")
    
    def _get_emoji(self, name):
        # 🎨 Fun emoji mapping
        emojis = {
            'apple': '🍎', 'banana': '🍌', 'pizza': '🍕',
            'coffee': '☕', 'book': '📚', 'game': '🎮'
        }
        return emojis.get(name.lower(), '📦')
    
    def calculate_total(self):
        subtotal = 0.0  # 💰 Start with float
        
        print("\n🛒 Your Cart:")
        print("-" * 40)
        
        for item in self.items:
            item_total = item['quantity'] * item['price']
            subtotal += item_total
            print(f"{item['emoji']} {item['name']:.<20} "
                  f"{item['quantity']} x ${item['price']:.2f} = ${item_total:.2f}")
        
        tax = subtotal * self.tax_rate
        total = subtotal + tax
        
        print("-" * 40)
        print(f"Subtotal: ${subtotal:.2f}")
        print(f"Tax (8%): ${tax:.2f}")
        print(f"💰 Total: ${total:.2f}")
        
        return total

# 🎮 Let's go shopping!
cart = SmartCart()
cart.add_item("Apple", 5, 0.99)  # 🍎 5 apples
cart.add_item("Pizza", 2, 12.99)  # 🍕 2 pizzas
cart.add_item("Coffee", 1, 4.50)  # ☕ 1 coffee

total = cart.calculate_total()

🎯 Try it yourself: Add a discount feature that applies percentage discounts to specific items!

🎮 Example 2: Physics Game Engine

Let’s make physics fun with numbers:

import math

# 🏃‍♂️ Simple physics simulation
class PhysicsObject:
    def __init__(self, name, x=0.0, y=0.0, mass=1.0):
        self.name = name
        self.x = x  # 📍 Position (float)
        self.y = y
        self.vx = 0.0  # 🚀 Velocity
        self.vy = 0.0
        self.mass = mass  # ⚖️ Mass (float)
        self.emoji = "🟦"  # Default emoji
        
    def apply_force(self, fx, fy, time=1.0):
        # 🎯 F = ma, so a = F/m
        ax = fx / self.mass
        ay = fy / self.mass
        
        # 📐 Update velocity: v = v0 + at
        self.vx += ax * time
        self.vy += ay * time
        
        # 🏃 Update position: x = x0 + vt
        self.x += self.vx * time
        self.y += self.vy * time
        
        print(f"{self.emoji} {self.name} moved to ({self.x:.1f}, {self.y:.1f})")
    
    def distance_to(self, other):
        # 📏 Calculate distance using Pythagorean theorem
        dx = self.x - other.x
        dy = self.y - other.y
        distance = math.sqrt(dx**2 + dy**2)
        return distance
    
    def has_collided(self, other, radius=1.0):
        # 💥 Check collision
        return self.distance_to(other) < radius * 2

# 🎮 Create game objects
player = PhysicsObject("Player", x=0, y=0, mass=2.0)
player.emoji = "🏃"

enemy = PhysicsObject("Enemy", x=10, y=10, mass=3.0)
enemy.emoji = "👾"

powerup = PhysicsObject("PowerUp", x=5, y=5, mass=0.5)
powerup.emoji = "⭐"

# 🚀 Apply forces and simulate movement
print("🎮 Game Physics Demo!")
print("-" * 40)

player.apply_force(5, 5)  # Move diagonally
enemy.apply_force(-3, -3)  # Move toward player

# 📊 Check distances
print(f"\n📏 Distance to enemy: {player.distance_to(enemy):.1f}")
print(f"📏 Distance to powerup: {player.distance_to(powerup):.1f}")

if player.has_collided(powerup, radius=2.0):
    print("⭐ You got the power-up! 🎉")

📊 Example 3: Financial Calculator with Complex Analysis

Advanced example using all number types:

# 💰 Financial calculator with compound interest
class InvestmentCalculator:
    def __init__(self):
        self.investments = []
        
    def add_investment(self, name, principal, rate, years, compounds_per_year=12):
        investment = {
            'name': name,
            'principal': float(principal),  # 💵 Initial amount
            'rate': float(rate) / 100,  # 📈 Convert percentage
            'years': int(years),  # 📅 Time period
            'n': int(compounds_per_year)  # 🔄 Compounding frequency
        }
        self.investments.append(investment)
        
    def calculate_compound_interest(self, investment):
        # 📐 A = P(1 + r/n)^(nt)
        P = investment['principal']
        r = investment['rate']
        n = investment['n']
        t = investment['years']
        
        # 🧮 Using complex numbers for advanced calculations
        compound_factor = complex(1 + r/n, 0)
        exponent = n * t
        
        # 💰 Calculate final amount
        amount = P * (compound_factor.real ** exponent)
        interest = amount - P
        
        return amount, interest
    
    def analyze_all(self):
        print("💼 Investment Analysis")
        print("=" * 50)
        
        total_invested = 0  # 🔢 Integer counter
        total_returns = 0.0  # 💰 Float for money
        
        for inv in self.investments:
            amount, interest = self.calculate_compound_interest(inv)
            total_invested += int(inv['principal'])
            total_returns += amount
            
            print(f"\n📊 {inv['name']}:")
            print(f"  💵 Principal: ${inv['principal']:,.2f}")
            print(f"  📈 Rate: {inv['rate']*100:.1f}%")
            print(f"  📅 Years: {inv['years']}")
            print(f"  💰 Final Amount: ${amount:,.2f}")
            print(f"  ✨ Interest Earned: ${interest:,.2f}")
            print(f"  🚀 Return: {(interest/inv['principal']*100):.1f}%")
        
        print("\n" + "=" * 50)
        print(f"💼 Total Invested: ${total_invested:,}")
        print(f"💰 Total Returns: ${total_returns:,.2f}")
        print(f"✨ Total Profit: ${(total_returns - total_invested):,.2f}")

# 🎯 Let's invest!
calc = InvestmentCalculator()
calc.add_investment("Savings Account", 10000, 2.5, 5, 12)
calc.add_investment("Stock Portfolio", 25000, 8.5, 10, 4)
calc.add_investment("Crypto Fund", 5000, 15.0, 3, 365)

calc.analyze_all()

🚀 Advanced Concepts

🧙‍♂️ Number Type Conversions

When you’re ready to level up, master type conversions:

# 🎯 Advanced type conversions
class NumberWizard:
    @staticmethod
    def demonstrate_conversions():
        # 🔄 Basic conversions
        float_num = 3.14159
        int_num = int(float_num)  # 3 (truncates, doesn't round!)
        
        # 🎨 Smart rounding
        rounded = round(float_num, 2)  # 3.14
        rounded_int = round(float_num)  # 3
        
        # 🚀 String to number conversions
        price_string = "19.99"
        price_float = float(price_string)  # 19.99
        
        quantity_string = "42"
        quantity_int = int(quantity_string)  # 42
        
        # 💫 Binary, octal, hexadecimal
        binary_num = 0b1010  # 10 in decimal
        octal_num = 0o12  # 10 in decimal  
        hex_num = 0xA  # 10 in decimal
        
        # 🎯 Complex conversions
        complex_from_string = complex("3+4j")  # (3+4j)
        
        print(f"✨ Float {float_num} → Int {int_num}")
        print(f"🎯 Binary {bin(10)} = Octal {oct(10)} = Hex {hex(10)}")

# 🪄 Try the magic!
wizard = NumberWizard()
wizard.demonstrate_conversions()

🏗️ Arbitrary Precision and Special Values

For the brave developers:

# 🚀 Working with very large numbers and special values
import decimal
import math

class AdvancedNumbers:
    @staticmethod
    def explore_limits():
        # 🌌 Python integers have unlimited precision!
        huge_number = 10 ** 100  # 1 googol
        even_bigger = huge_number ** 10  # Mind-blowing!
        
        print(f"🌟 A googol has {len(str(huge_number))} digits!")
        
        # 💰 Decimal precision for money
        decimal.getcontext().prec = 4  # Set precision
        price = decimal.Decimal('19.99')
        tax = decimal.Decimal('0.08')
        total = price * (1 + tax)  # Exact decimal math!
        
        print(f"💵 Exact total: ${total}")
        
        # 🎯 Special float values
        infinity = float('inf')
        negative_infinity = float('-inf')
        not_a_number = float('nan')
        
        print(f"♾️  Infinity + 1 = {infinity + 1}")
        print(f"🤔 Is NaN equal to itself? {not_a_number == not_a_number}")  # False!
        
        # 🔬 Math constants
        print(f"🥧 Pi = {math.pi}")
        print(f"📐 e = {math.e}")
        print(f"🌟 Tau = {math.tau}")  # 2π

# 🎮 Explore the limits!
AdvancedNumbers.explore_limits()

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Float Precision Issues

# ❌ Wrong way - float precision can surprise you!
total = 0.1 + 0.2
print(total == 0.3)  # False! 😱
print(f"0.1 + 0.2 = {total}")  # 0.30000000000000004

# ✅ Correct way - use proper comparison!
import math

# Method 1: Use math.isclose()
result = 0.1 + 0.2
print(math.isclose(result, 0.3))  # True! ✅

# Method 2: Use decimal for money
from decimal import Decimal
price1 = Decimal('0.10')
price2 = Decimal('0.20')
total = price1 + price2
print(total == Decimal('0.30'))  # True! ✅

🤯 Pitfall 2: Integer Division Confusion

# ❌ Dangerous - might not give expected result!
pizza_slices = 10
people = 3
slices_per_person = pizza_slices / people  # 3.333...

# 😱 Can't give someone 0.333 of a slice!
print(f"Each person gets {slices_per_person} slices")

# ✅ Safe - use integer division!
slices_per_person = pizza_slices // people  # 3
leftover = pizza_slices % people  # 1

print(f"🍕 Each person gets {slices_per_person} slices")
print(f"🍕 {leftover} slice(s) left over!")

💥 Pitfall 3: Type Mixing Errors

# ❌ Wrong - mixing strings and numbers
user_input = "42"
try:
    result = user_input + 8  # 💥 TypeError!
except TypeError as e:
    print(f"❌ Error: {e}")

# ✅ Correct - convert first!
user_input = "42"
number = int(user_input)  # Convert to int
result = number + 8  # 50
print(f"✅ Result: {result}")

# 🛡️ Even better - validate input!
def safe_add(user_input, number_to_add):
    try:
        num = float(user_input)
        return num + number_to_add
    except ValueError:
        print(f"⚠️ '{user_input}' is not a valid number!")
        return None

result = safe_add("42.5", 7.5)  # 50.0 ✅

🛠️ Best Practices

🎯 Choose the Right Type: Use integers for counting, floats for measurements
💰 Money Matters: Use Decimal for financial calculations
🛡️ Validate Input: Always check user input before converting
📊 Avoid Float Comparison: Use math.isclose() instead of ==
✨ Document Units: Always specify units in variable names (e.g., price_usd, distance_km)

🧪 Hands-On Exercise

🎯 Challenge: Build a Scientific Calculator

Create a calculator that handles different number types:

📋 Requirements:

✅ Basic operations (+, -, *, /, //, %, **)
🔬 Scientific functions (sqrt, sin, cos, log)
💰 Financial mode with decimal precision
📊 Statistics mode (mean, median, mode)
🎨 Each mode should have its own emoji theme!

🚀 Bonus Points:

Add memory functions (M+, M-, MR, MC)
Implement unit conversions
Create a history feature
Add complex number support

💡 Solution

🔍 Click to see solution

import math
import statistics
from decimal import Decimal, getcontext

# 🎯 Our multi-mode calculator!
class ScientificCalculator:
    def __init__(self):
        self.memory = 0
        self.history = []
        self.mode = "standard"  # standard, scientific, financial, statistics
        getcontext().prec = 10  # Set decimal precision
        
    def set_mode(self, mode):
        modes = {
            "standard": "🔢",
            "scientific": "🔬", 
            "financial": "💰",
            "statistics": "📊"
        }
        if mode in modes:
            self.mode = mode
            print(f"{modes[mode]} Switched to {mode} mode!")
        else:
            print("❌ Invalid mode!")
    
    def calculate(self, operation, *args):
        result = None
        
        if self.mode == "standard":
            result = self._standard_calc(operation, *args)
        elif self.mode == "scientific":
            result = self._scientific_calc(operation, *args)
        elif self.mode == "financial":
            result = self._financial_calc(operation, *args)
        elif self.mode == "statistics":
            result = self._statistics_calc(operation, *args)
        
        if result is not None:
            self.history.append(f"{operation}: {result}")
            print(f"✨ Result: {result}")
        
        return result
    
    def _standard_calc(self, op, a, b=None):
        ops = {
            'add': lambda: a + b,
            'subtract': lambda: a - b,
            'multiply': lambda: a * b,
            'divide': lambda: a / b if b != 0 else "❌ Division by zero!",
            'floor_divide': lambda: a // b if b != 0 else "❌ Division by zero!",
            'modulo': lambda: a % b if b != 0 else "❌ Division by zero!",
            'power': lambda: a ** b
        }
        
        if op in ops and b is not None:
            return ops[op]()
        else:
            return "❌ Invalid operation!"
    
    def _scientific_calc(self, op, x):
        ops = {
            'sqrt': lambda: math.sqrt(x) if x >= 0 else "❌ Can't sqrt negative!",
            'sin': lambda: math.sin(math.radians(x)),
            'cos': lambda: math.cos(math.radians(x)),
            'tan': lambda: math.tan(math.radians(x)),
            'log': lambda: math.log10(x) if x > 0 else "❌ Can't log non-positive!",
            'ln': lambda: math.log(x) if x > 0 else "❌ Can't log non-positive!",
            'factorial': lambda: math.factorial(int(x)) if x >= 0 else "❌ No negative factorial!"
        }
        
        if op in ops:
            return ops[op]()
        else:
            return "❌ Invalid scientific operation!"
    
    def _financial_calc(self, op, *args):
        if op == 'compound_interest':
            P, r, n, t = args
            P = Decimal(str(P))
            r = Decimal(str(r)) / 100
            n = int(n)
            t = int(t)
            
            amount = P * (1 + r/n) ** (n*t)
            return float(amount.quantize(Decimal('0.01')))
        
        elif op == 'loan_payment':
            P, r, n = args
            P = Decimal(str(P))
            r = Decimal(str(r)) / 100 / 12  # Monthly rate
            n = int(n) * 12  # Total months
            
            if r == 0:
                return float(P / n)
            
            payment = P * (r * (1 + r)**n) / ((1 + r)**n - 1)
            return float(payment.quantize(Decimal('0.01')))
        
        return "❌ Invalid financial operation!"
    
    def _statistics_calc(self, op, data):
        if not data:
            return "❌ No data provided!"
        
        ops = {
            'mean': lambda: statistics.mean(data),
            'median': lambda: statistics.median(data),
            'mode': lambda: statistics.mode(data) if len(set(data)) < len(data) else "No mode",
            'stdev': lambda: statistics.stdev(data) if len(data) > 1 else "Need more data",
            'variance': lambda: statistics.variance(data) if len(data) > 1 else "Need more data"
        }
        
        if op in ops:
            return ops[op]()
        else:
            return "❌ Invalid statistics operation!"
    
    def memory_add(self, value):
        self.memory += value
        print(f"💾 Memory: {self.memory}")
    
    def memory_clear(self):
        self.memory = 0
        print("🗑️ Memory cleared!")
    
    def show_history(self):
        print("\n📜 Calculation History:")
        for calc in self.history[-5:]:  # Show last 5
            print(f"  • {calc}")

# 🎮 Test our calculator!
calc = ScientificCalculator()

# Standard mode
print("🔢 Standard Operations:")
calc.calculate('add', 10, 5)
calc.calculate('power', 2, 10)

# Scientific mode
print("\n🔬 Scientific Operations:")
calc.set_mode('scientific')
calc.calculate('sqrt', 16)
calc.calculate('sin', 30)

# Financial mode
print("\n💰 Financial Calculations:")
calc.set_mode('financial')
# $10,000 at 5% for 10 years, compounded monthly
calc.calculate('compound_interest', 10000, 5, 12, 10)

# Statistics mode
print("\n📊 Statistics:")
calc.set_mode('statistics')
data = [23, 45, 67, 45, 89, 45, 23, 67, 78]
calc.calculate('mean', data)
calc.calculate('median', data)
calc.calculate('mode', data)

# Show history
calc.show_history()

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

✅ Work with integers, floats, and complex numbers with confidence 💪
✅ Avoid common precision and type errors that trip up beginners 🛡️
✅ Apply number types correctly in real projects 🎯
✅ Debug number-related issues like a pro 🐛
✅ Build awesome calculations with Python! 🚀

Remember: Choosing the right number type is like choosing the right tool for the job. Master them all, and you’ll be unstoppable! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered working with numbers in Python!

Here’s what to do next:

💻 Practice with the calculator exercise above
🏗️ Build a small project using different number types
📚 Move on to our next tutorial: String manipulation in Python
🌟 Share your number wizardry with others!

Remember: Every Python expert started by counting from 0. Keep coding, keep calculating, and most importantly, have fun! 🚀

Happy coding! 🎉🚀✨

Prerequisites

What you'll learn