# Python Numbers

## Python Numbers: A Comprehensive Guide

Python supports several numeric data types, including integers, floating-point numbers, and complex numbers. This tutorial will provide a detailed explanation of each type and help you understand how to work with numbers in Python effectively. We'll cover various operations, functions, and techniques for manipulating numbers.

1. Integer Numbers (int)
2. Floating-Point Numbers (float)
3. Complex Numbers (complex)
4. Arithmetic Operations
5. Comparison Operations
6. Python Built-in Functions for Numbers
7. The math Module
8. The random Module
9. Rounding and Formatting Numbers

## 1. Integer Numbers (int)

Integers are whole numbers (positive, negative, or zero) without any decimal points. In Python, you can represent integers using the `int` data type. Here's how to create and work with integer variables:

``````# Integer variable
my_integer = 42

result = 5 + 3  # 8

# Subtracting integers
result = 10 - 3  # 7

# Multiplying integers
result = 5 * 3  # 15

# Dividing integers (integer division)
result = 10 // 3  # 3 (floor division, truncates the decimal part)
``````

## 2. Floating-Point Numbers (float)

Floating-point numbers are real numbers that can have a fractional part. In Python, you can represent floating-point numbers using the `float` data type. Here's how to create and work with float variables:

``````# Float variable
my_float = 3.14

result = 2.5 + 1.5  # 4.0

# Subtracting floats
result = 5.3 - 3.1  # 2.2

# Multiplying floats
result = 1.5 * 2.0  # 3.0

# Dividing floats
result = 10 / 3  # 3.3333333333333335 (regular division, keeps the decimal part)
``````

## 3. Complex Numbers (complex)

Complex numbers are numbers that have both a real and an imaginary part. In Python, you can represent complex numbers using the `complex` data type. Here's how to create and work with complex variables:

``````# Complex variable
my_complex = 3 + 4j

# Complex variable using the complex() function
my_complex = complex(3, 4)  # 3 + 4j

# Accessing real and imaginary parts
real_part = my_complex.real  # 3.0
imaginary_part = my_complex.imag  # 4.0

result = (3 + 4j) + (2 + 3j)  # 5 + 7j

# Subtracting complex numbers
result = (3 + 4j) - (2 + 3j)  # 1 + 1j

# Multiplying complex numbers
result = (3 + 4j) * (2 + 3j)  # -6 + 17j

# Dividing complex numbers
result = (3 + 4j) / (2 + 3j)  # 1.3846153846153846 - 0.46153846153846156j
``````

## 4. Arithmetic Operations in Python

Python supports various arithmetic operations on numbers, such as addition, subtraction, multiplication, division, exponentiation, and modulo. Here are some examples:

``````# Addition
result = 5 + 3  # 8

# Subtraction
result = 10 - 3  # 7

# Multiplication
result = 5 * 3  # 15

# Division
result = 10 / 3  # 3.3333333333333335

# Integer (floor) division
result = 10 // 3  # 3

# Modulo (remainder)
result = 10 % 3  # 1

# Exponentiation (power)
result = 2 ** 3  # 8
``````

## 5. Comparison Operations

Python also supports various comparison operations on numbers, such as equality, inequality, greater than, less than, greater than or equal to, and less than or equal to. Comparison operations return boolean values (`True` or `False`). Here are some examples:

``````# Equality
result = 5 == 3  # False

# Inequality
result = 5 != 3  # True

# Greater than
result = 5 > 3  # True

# Less than
result = 5 < 3  # False

# Greater than or equal to
result = 5 >= 3  # True

# Less than or equal to
result = 5 <= 3  # False
``````

## 6. Python Built-in Functions for Numbers

Python provides several built-in functions for working with numbers, such as `abs()`, `divmod()`, `max()`, `min()`, `pow()`, `round()`, and `sum()`. Here are some examples:

``````# Absolute value
result = abs(-5)  # 5

# Divmod (quotient and remainder)
result = divmod(10, 3)  # (3, 1)

# Maximum value
result = max(3, 5, 2)  # 5

# Minimum value
result = min(3, 5, 2)  # 2

# Power (exponentiation)
result = pow(2, 3)  # 8

# Rounding
result = round(3.14159, 2)  # 3.14

# Sum
result = sum([1, 2, 3, 4, 5])  # 15
``````

## 7. The math Module

The `math` module provides additional mathematical functions for working with numbers, such as `ceil()`, `floor()`, `sqrt()`, `log()`, `sin()`, `cos()`, and `factorial()`. Here are some examples:

``````import math

# Ceiling (smallest integer greater than or equal to the number)
result = math.ceil(3.1)  # 4

# Floor (largest integer less than or equal to the number)
result = math.floor(3.1)  # 3

# Square root
result = math.sqrt(9)  # 3.0

# Logarithm
result = math.log(100, 10)  # 2.0 (base 10 logarithm)

# Trigonometry (sin, cos, tan)
result = math.sin(math.pi / 2)  # 1.0

# Factorial
result = math.factorial(5)  # 120
``````

## 8. The random Module

The `random Module

The `random` module provides functions for generating random numbers, such as `randint()`, `randrange()`, `random()`, `uniform()`, and `choice()`. Here are some examples:

``````import random

# Random integer between a and b (inclusive)
result = random.randint(1, 10)  # a random integer between 1 and 10

# Random integer from start (inclusive) to stop (exclusive) with a step
result = random.randrange(0, 10, 2)  # a random even integer between 0 and 10

# Random float between 0 and 1
result = random.random()  # a random float between 0 and 1

# Random float between a and b
result = random.uniform(1, 5)  # a random float between 1 and 5

# Random choice from a sequence
result = random.choice([1, 2, 3, 4, 5])  # a random element from the list
``````

## 9. Rounding and Formatting Numbers in Python

When working with numbers in Python, you might need to round or format them for display or further calculations. Here are some examples of rounding and formatting numbers:

``````# Rounding a float to a specific number of decimal places
rounded = round(3.14159, 2)  # 3.14

# Formatting a float as a string with a specific number of decimal places
formatted = "{:.2f}".format(3.14159)  # '3.14'

# Using f-strings to format a float with a specific number of decimal places
formatted = f"{3.14159:.2f}"  # '3.14'

# Formatting an integer as a string with leading zeros
formatted = "{:03}".format(42)  # '042'

# Using f-strings to format an integer with leading zeros
formatted = f"{42:03}"  # '042'
``````

In this lesson of our python tutorial, we've covered the different types of numbers in Python (`int`, `float`, and `complex`) and various operations, functions, and techniques for working with them. By understanding how to work with numbers in Python, you'll be well-equipped to perform calculations and manipulate data in a wide range of applications. Reach out to Whitewood Media & Web Development if you have any suggestions or code corrections.

### Q: What are the basic numeric types in Python?

A: Python has three basic numeric types: integers (`int`), floating-point numbers (`float`), and complex numbers (`complex`). Integers are whole numbers, floating-point numbers have decimal points, and complex numbers have both real and imaginary parts.

### Q: How can I perform arithmetic operations on numbers in Python?

A: Python supports various arithmetic operations on numbers, such as addition (+), subtraction (-), multiplication (*), division (/), integer (floor) division (//), modulo (remainder) (%), and exponentiation (power) (**). You can perform these operations using the appropriate symbols between the numbers.

### Q: How can I compare numbers in Python?

A: Python supports various comparison operations on numbers, such as equality (==), inequality (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=). Comparison operations return boolean values (`True` or `False`).

### Q: What built-in functions are available for working with numbers in Python?

A: Python provides several built-in functions for working with numbers, such as `abs()`, `divmod()`, `max()`, `min()`, `pow()`, `round()`, and `sum()`.

### Q: How can I use the math module to perform advanced mathematical operations in Python?

A: The `math` module provides additional mathematical functions for working with numbers, such as `ceil()`, `floor()`, `sqrt()`, `log()`, `sin()`, `cos()`, and `factorial()`. To use these functions, you need to import the math module using `import math`.

### Q: How can I generate random numbers in Python?

A: The `random` module provides functions for generating random numbers, such as `randint()`, `randrange()`, `random()`, `uniform()`, and `choice()`. To use these functions, you need to import the random module using `import random`.

### Q: How can I round and format numbers in Python?

A: You can round numbers using the `round()` function, which rounds a float to a specific number of decimal places. To format numbers as strings, you can use the `format()` method, f-strings, or other string formatting techniques.