In Python, numbers are a fundamental data type used to represent numeric values. There are three primary numeric types in Python:

int (Integer): Integers represent whole numbers, both positive and negative, without any fractional parts. For example, 5 , 10 , and 0 are all integers.

float (FloatingPoint): Floatingpoint numbers represent decimal numbers or numbers with a fractional part. They are expressed in scientific notation or with a decimal point. . For example, 3.14 , 2.5 , and 1.0e6 are floatingpoint numbers.

complex (Complex): Complex numbers are used to represent numbers with both real and imaginary parts. They are expressed in the form a + bj, where a denotes the genuine component and b is the imaginary component. For example, 2 + 3j represents a complex number with a real part of 2 and an imaginary part of 3 .
Examples of Python Numbers:
# Integer
x = 42
# FloatingPoint
pi = 3.14
# Complex
z = 2 + 3j
When you assign a variable of a numeric type a value, you create a numeric type variable:
Example:
x = 1 # int
y = 2.8 # float
z = 1j # complex
To verify the type of any object in Python, use the type() function:

Python provides a wide range of arithmetic and mathematical operations that can be performed on numeric types. Some common operations include addition, subtraction, multiplication, division, modulus (remainder), exponentiation, etc.
Example:
# Arithmetic operations
a = 10
b = 3
addition = a + b
subtraction = a  b
multiplication = a * b
division = a / b
remainder = a % b
exponentiation = a ** b
print(addition) # Output: 13
print(subtraction) # Output: 7
print(multiplication) # Output: 30
print(division) # Output: 3.3333333333333335
print(remainder) # Output: 1
print(exponentiation) # Output: 1000
Remember: that Python automatically determines the data type based on the assigned value, so you don't need to explicitly declare the type when working with numeric values.

Python's numeric data types are versatile and powerful, allowing you to work with a wide range of numerical values and perform complex calculations with ease.
Int

A full number, positive or negative, without decimals, and with an indefinite length is known as a "integer."

In Python, the int data type is used to represent integers, which are whole numbers without any fractional part.

Integers can be zero, positive, or negative. Python's int data type has unlimited precision, which means it can represent integers of any size, as long as there is enough memory available to store them.
Example:
x = 1
y = 35656222554887711
z = 3255522
print(type(x))
print(type(y))
print(type(z))
Now Try it Yourself.>>
Python automatically determines the data type based on the assigned value. For example, when you write x = 42 , Python recognizes that the value 42 is an integer and assigns the int data type to the variable x . Keep in mind that Python's int data type has unlimited precision, which means it can handle very large integers without overflow. This can be especially useful in situations where precise calculations with large numbers are required.
However, it's essential to be mindful of memory usage when dealing with extremely large integers, as they can consume a lot of memory.

Float

A positive or negative number with one or more decimals is referred to as a "float," or "floating point number."

In Python, the float data type is used to represent floatingpoint numbers, which are numbers with a fractional part.

Floatingpoint numbers are also used to represent numbers with a large or small magnitude, as they can be written using scientific notation.
Floatingpoint numbers are written with a decimal point and can include an exponent to represent very large or very small values.
# Example
x = 3.14 # A positive floatingpoint number
y = 2.5 # A negative floatingpoint number
z = 1.0e6 # A floatingpoint number using scientific notation (1.0 x 10^6)
Based on the provided value, Python identifies the data type automatically. When you write x = 3.14 , Python recognizes that the value 3.14 is a floatingpoint number and assigns the float data type to the variable x .
Floatingpoint numbers can be used in various mathematical operations, just like integers.
Here are some examples:
#Example
a = 3.0
b = 2.0
addition = a + b
subtraction = a  b
multiplication = a * b
division = a / b
exponentiation = a ** b
print(addition) # Output: 5.0
print(subtraction) # Output: 1.0
print(multiplication) # Output: 6.0
print(division) # Output: 1.5
print(exponentiation) # Output: 9.0
Example:
Floats:
x = 1.10
y = 1.0
z = 35.59
print(type(x))
print(type(y))
print(type(z))
Scientific numbers with a "e" to denote the power of 10 can also be used as floating points.
Example:
Floats:
x = 35e3
y = 12E4
z = 87.7e100
print(type(x))
print(type(y))
print(type(z))
Now Try it Yourself.>>
Floatingpoint numbers are widely used in scientific and engineering calculations, as well as any application that requires precise representation of decimal numbers or handling large or small numerical values. However, it's important to be aware of floatingpoint limitations, such as potential rounding errors due to the finite precision of floatingpoint representation. In some cases, these limitations can lead to unexpected results in computations involving floatingpoint numbers.

Complex

Imaginary parts of complex numbers are written with a "j".

In Python, the complex data type is used to represent complex numbers, which are numbers with both a real part and an imaginary part.

The formula for complex numbers is a + bj, where a denotes the real part and b the imaginary part. In this representation, a and b are both real numbers, and j represents the square root of 1, which is an imaginary unit.

In most programming languages, including Python, the imaginary unit is denoted by "j" , while in some other mathematical notations, it is represented by "i" .
Here are some examples of complex numbers in Python:
z1 = 2 + 3j # Complex number with a real part of 2 and an imaginary part of 3
z2 = 1.5  2j # Complex number with a real part of 1.5 and an imaginary part of 2
z3 = 4j # Complex number with a real part of 0 and an imaginary part of 4
Python allows you to perform various arithmetic operations with complex numbers, just like with integers and floatingpoint numbers.
For example:
a = 2 + 3j
b = 1  1j
addition = a + b
subtraction = a  b
multiplication = a * b
print(addition) # Output: (3+2j)
print(subtraction) # Output: (1+4j)
print(multiplication) # Output: (5+1j)
You can also access the real and imaginary parts of a complex number using the real and imag attributes, respectively:
z = 2 + 3j
real_part = z.real # Output: 2.0
imaginary_part = z.imag # Output: 3.0
Example:
Complex:
x = 3+5j
y = 5j
z = 5j
print(type(x))
print(type(y))
print(type(z))
Now Try it Yourself.>>
Complex numbers are used in various scientific, engineering, and mathematical applications, where the representation of quantities involving both magnitude and phase is required. Python's support for complex numbers makes it a versatile language for handling a wide range of numerical computations.

Type Conversion

In Python, type conversion (also known as type casting) is the process of converting one data type to another.

Python provides builtin functions to perform type conversion, allowing you to change the data type of a value as needed.
You can convert from one type to another with the int() , float() , and complex() methods:
Example:
Converting between two types:
x = 1 # int
y = 2.8 # float
z = 1j # complex
#convert from int to float:
a = float(x)
#convert from float to int:
b = int(y)
#convert from int to complex:
c = complex(x)
print(a)
print(b)
print(c)
print(type(a))
print(type(b))
print(type(c))
Now Try it Yourself.>>

Note: You cannot convert complex numbers into another number type.

Random Number
Python does not have a random() function to make a random number, but Python has a builtin module called random that can be used to make random numbers:
Example:
Display a random number between 1 and 9 after importing the random module:
import random
print(random.randrange(1, 10))
Now Try it Yourself.>>
