Cracking the Code: Exploring Python's Numeric World - w9school

Python Numbers

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

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

2. float (Floating-Point): Floating-point 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.0e-6 are floating-point numbers.

3. 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

# Floating-Point
pi = 3.14

# Complex
z = 2 + 3j

When you assign a variable of a numeric type a value, you create a numeric type variable: 

x = 1    # int
y = 2.8  # float
z = 1j   # complex

print(type(x))
print(type(y))
print(type(z))

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.

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 floating-point numbers, which are numbers with a fractional part.

• Floating-point numbers are also used to represent numbers with a large or small magnitude, as they can be written using scientific notation.

Floating-point 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 floating-point number
y = -2.5       # A negative floating-point number
z = 1.0e-6     # A floating-point number using scientific notation (1.0 x 10^-6)

#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

x = 1.10
y = 1.0
z = -35.59

print(type(x))
print(type(y))
print(type(z))

x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))

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

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)

z = 2 + 3j
real_part = z.real     # Output: 2.0
imaginary_part = z.imag  # Output: 3.0

x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))

Type Conversion

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

• Python provides built-in 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:

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))

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 built-in module called random that can be used to make random numbers:

import random

print(random.randrange(1, 10))