# Python Numbers Helper

In our previous tutorial on datatypes, we gained a basic understanding of `Python Numbers`

. Now, get ready to take a deep dive into the captivating world of Python numbers. We’re going to cover everything you need to know about handling numbers in Python, ensuring that you have a solid foundation to conquer any numerical challenge that comes your way. So, let’s dive right in and explore Python numbers `together!`

## What are Python numbers?

`Python numbers`

refer to the data types and operations used for working with numerical values in the Python programming language. Python numbers come in different flavors. The primary numeric data types are `integers`

, `floating-point numbers`

, and `complex numbers`

, along with various operations and functions for performing mathematical calculations..

Let’s take a closer look at each of them and explore how they work.

### I. Integers

Integers are whole numbers, both `positive`

and `negative`

, without any decimal points. They are used in a variety of scenarios, from counting items to performing mathematical operations and representing discrete quantities. Imagine you have a group of `friends`

and each of them owns a certain number of `cats`

. Let’s see how Python integers can help us count the `total number`

of cats:

In above example, we assign the number of cats owned by `Alice`

, `Bob`

, and `Charlie `

to their respective variables. Then, we calculate the total number of `cats`

by adding the individual counts together. Finally, we display the result:

### II. Floating-Point Numbers

Floating-point numbers, or `floats`

, are a type of numerical data in Python that allow for precise representation of `decimal`

values. They are used when dealing with numbers that require `fractional precision`

or `scientific notation`

. Understanding floats is crucial for accurate calculations involving measurements, financial data, and scientific computations. Let’s imagine we want to calculate the net worth of a popular celebrity using Python floats. We’ll use the example of `Taylor Swift`

, a globally recognized artist known for her successful music career:

In the code above, we assign Taylor Swift’s `assets`

and `liabilities`

to the respective variables. By subtracting the liabilities from the assets, we determine her net worth. The output will be:

### III. Complex Numbers

Complex numbers are a fascinating aspect of `mathematics`

, and Python provides built-in support to work with them. A complex number consists of a real part and an imaginary part, represented as “`a + bj,`

” where “`a`

” is the real part, “`b`

” is the imaginary part, and “`j`

” represents the imaginary unit. Complex numbers find applications in various fields, including `engineering`

, `physics`

, and `signal processing`

.

Let’s examine how to add complex numbers using Python. Consider the following two examples involving `popular celebrities`

:

In this example, we have complex numbers representing the wealth of two popular celebrities: `Jay-Z`

and `Beyoncé`

. By adding these complex numbers together, we obtain the total wealth of the couple. The output will be:

Python also provides `functions`

to calculate the `conjugate`

and `absolute`

value of a complex number. Let’s use examples to demonstrate their usage:

For this example, we define a complex number `3 + 4j`

. By calling the `conjugate()`

function on the complex number, we obtain its conjugate. The output will be:

Now let’s Calculate the Absolute Value:

Above, we define a complex number `-5 + 12j`

. By using the `abs()`

function and passing the complex number as an argument, we calculate its absolute value. The output will be:

To visualize complex numbers, let’s plot a few points on the complex plane using Python. We’ll use the example of the iconic `Eiffel Tower`

in Paris:

In the code above, we create `three complex numbers `

representing points on the complex plane near the `Eiffel Tower`

. Using the matplotlib library, we plot these points with different colors and labels. The resulting plot visualizes the locations of the points in the complex plane. Don’t worry, You’ll soon dive into the wonderful world of `matplotlib`

in our upcoming articles. We’ll take a detailed look at this amazing library and explore all its exciting features together.

## Underscores in Numbers

In Python, you can use underscores `_`

as visual separators within numeric values. These underscores are completely ignored by the interpreter and have no impact on the actual value of the number. Instead, they serve as visual aids to enhance readability, especially for large or complex numeric literals.

Let’s say we have a large number representing the `world's population`

. Without underscores, it can be challenging to read and comprehend the magnitude of the value. However, by using underscores, we can make the number more manageable and easier to understand:

Above, we define the world population as `7_900_000_000`

, with underscores separating the digits into groups of three. This format helps us quickly grasp the approximate value of the world population. The output will be something like:

Underscores can also be used in `floating-point numbers`

to improve readability. They can be placed anywhere between digits, except at the beginning or end of the number. Let’s consider a monetary value representing a popular celebrity’s net worth. Using underscores, we can make the number more readable and easier to interpret:

Above, we define the celebrity’s net worth as `1_500_000_000.75`

, with underscores separating the digits for clarity. By using underscores, we make it easier to identify the major digits and the decimal portion. The output might be:

## Python Random Numbers

Random numbers play a vital role in various applications, from `games`

and `simulations`

to cryptography and `statistical analysis`

. Python provides a robust random number generation module that allows you to generate `pseudo-random`

numbers using different algorithms. These numbers appear random and are crucial for introducing unpredictability and variability into your programs.

Example: Rolling the Dice Let’s kick things off with a classic example involving a popular game – `rolling dice`

. Imagine we’re in the vibrant city of Las Vegas, and we want to simulate rolling two six-sided dice:

Above, we import the `random`

module and use the `randint()`

function to generate random integers between `1`

and `6`

, simulating the roll of two dice. We then display the results using friendly and conversational language. The output will be something like:

Python random numbers can use with functions to make random choices from a list of items. This can be handy when you want to introduce variability or simulate random selection scenarios. Let’s imagine you’re planning a dream `vacation`

and need some inspiration. We have a list of popular vacation `destinations`

and want to randomly select one using Python:

In this example, we import the `random`

module and create a list of popular vacation destinations. Using the `choice()`

function, we randomly select one destination from the `list`

and display it with a friendly message.

Python random numbers also allows you to shuffle elements within a list. Let’s shuffle a `deck of cards`

and display a few random cards from the shuffled deck:

For this example, we import the `random`

module again and create a `list`

representing a `deck of cards`

. By using the `shuffle()`

function, we randomly shuffle the order of the cards. Then, we use the `sample()`

function to select five random cards from the shuffled deck. The output could be something like:

### What is 1e 5 in Python?

In Python, `1e5`

is a way to represent a number using scientific notation. Specifically, `1e5`

represents the number `1`

multiplied by `10`

raised to the power of `5`

, which is equal to `100,000`

.

Here’s an example of how `1e5`

can be used in Python:

When you run this code, it will output `100000`

, which is the numerical value represented by `1e5`

.

Scientific notation is commonly used to express large or small numbers in a concise and readable format. The `e`

in `1e5`

stands for exponent, and the number following it indicates the power of 10 by which the base number (in this case, 1) is multiplied. In the case of `1e5`

, the base number 1 is multiplied by 10 raised to the power of 5.

### How do you write 10 3 in Python?

To express `10`

to the power of `3`

in Python, you can use the double asterisk operator `**`

to perform exponentiation. Here’s an example:

In this code, `10 ** 3`

calculates `10`

raised to the power of `3`

, which equals `1000`

. The result is stored in the `result`

variable. When you run this code, the output will be:

**In conclusion**, Python Numbers offer a diverse range of data types and operations for working with numerical values in the Python programming language. By understanding these concepts, you are equipped with the tools to tackle any numerical challenge that comes your way.

We explored the different types of `Python numbers`

, including `integers`

, `floating-point `

numbers, and `complex `

numbers. We saw how integers can be used for counting and performing mathematical operations, while floats are essential for precise calculations involving decimal values. Complex numbers, with their real and imaginary parts, find applications in various fields. We also learned how to calculate the `conjugate`

and` absolute`

value of complex numbers and even plotted points on the complex plane using matplotlib.

We also discovered a handy technique in Python numbers: using underscores in numbers. By using underscores as visual separators within numeric values, we can enhance readability, especially for large or complex numbers. This technique can be applied to both integers and floating-point numbers, making it easier to comprehend their magnitude.

With this newfound knowledge and a solid understanding of Python Numbers, you are well-prepared to embark on exciting numerical adventures and unleash the full potential of Python in your programming endeavors. So, embrace the power of numbers and continue your journey into the captivating world of Python!