**Python Float**: Programmers employ different data types (strings, integers, complex numbers, float) to store values depending on how they wish to manipulate a value. For example, you might want to run a mathematical operation but if your data type is a string, it will result in an error. Similarly, if you use a decimal number as input, you can not use integers for that.

As a primitive element of programming, Python allows programmers to create floating-point objects. The built-in function float() in Python lets you convert data types like integers or strings to floating-point numbers.

In this blog, we will understand how float in Python works and explore different float methods with examples. We will also look at how we can use Python round float to include additional parameters when rounding and find out how a Python random float is generated. So, let’s get started.

## Table of Content

## Python Float

Float in computer science is a data type that denotes a fraction or a number in decimal format. It allows programmers a greater degree of precision when compared to integers. In Python, we use the float() method to return a float data type when the input is any specified value, string, or number.

**Syntax**

float(value) // where the value is either a string or a number.

It’s optional if you want to pass a parameter or not. The default value of float() is 0.0. If the built-in float() method is unable to return a float point number from a string or number, it will raise the ValueError. It will also return an error if the integer you pass is beyond the Python float() range.

Floating-point numbers play a significant role in programming, especially when denoting currencies. They are highly efficient at providing processing power in graphic libraries where they are used extensively. Since it can tolerate rounding errors arising from the precision of up to seven digits, the float can help you write more precise and accessible code.

Learn data science courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

### How does Float in Python work?

Here’s looking at the different functions you can perform on the float easily

#### 1. Convert an Integer to a Float in Python

Converting an integer into a floating-point number in Python is straightforward. Here’s an example

```
float_no = float(15)
print(float_no)
```

Output: 15.0.

#### 2. Convert a String to a Float in Python :

A string in Python is considered a collection of characters. To convert a string to a floating-point number using the float() method, the string must be expressed in numerical format. Here’s an example:

```
float_str = float(“15”)
print(float_str)
```

Output: 15.0.

If you add the positive (+) or negative (-) signs to the string, the method will convert the string to a positive float or negative float, respectively

whether you want your string to be converted to a positive float or a negative float. For example:

```
float_str = float(“-15”)
print(float_str)
```

Output: -15.0

Floats can also be expressed in scientific notation where E or e denotes the power of 10. For example, 1.5e3 = 1.5 x 103 = 1500).

Here’s an example:

```
print(float(2e-002))
print(float(“2e-002”))
print(float(‘+1E3’))
```

Output:

0.02

0.02

1000.0

You can also include invalid numbers or infinity values in the string: NaN, infinity, or inf.

For example:

```
print(“True: “, float(True))
print(“False: “, float(False))
print(“Nan: “, float(‘nan’))
print(“Infinity: “, float(‘inf’))
```

Output

True: 1.0

False: 0.0

Nan: nan

Infinity: inf

#### 3. Typecasting using Float() :

We will now use float() to find out how it works with strings and integers. In the following program, we will convert the type from integer to float:

```
s=100
print(“s=”,s)
print(“Before: “,type(s))
s=float(s)
print(“s=”,s)
print(“After: “,type(s))
```

Output:

s= 100

Before: <class ‘int’>

s= 100.0

After: <class ‘float’>

If the input is not an integer and is instead a string, it will still convert into a floating-point number. However, if the string contains characters, it will result in ValueError.

#### 4. Rounding Float in Python

If you want an approximate value for your floating-point number that isn’t excessively precise, you can round it to the decimal point you require. For example, rounding the floating-point number to 5.1235 rounded to the hundredth place is 5.12.

In Python, there is a built-in function Round() that helps you round a float number. Python round float returns a float that is rounded as per the input you provide. In case the decimal place is not specified, Python takes it to be 0 and then rounds it to the nearest integer.

**Syntax**

round(float_num, num_of_decimals)

- The two arguments float_num and num_of_decimals indicate the float you want to round and the decimal place you want it to be rounded to respectively
- num_of_decimals is optional as we mentioned above
- If num_of_decimals is a negative integer, the Python round float function will round it to the digit occurring before the decimal point

Let’s understand this with an example

```
float_num1 = 11.7
float_num2 = 11.4
float_num3 = 11.2345
float_num4 = 11.5678
float_num5= 123.45
print(round(float_num1))
print(round(float_num2))
print(round(float_num3, 2))
print(round(float_num4, 2))
print(round(float_num5, -1))
```

Output:

12

11

11.23

11.57

120.0

## Conclusion

Python uses float class to represent real numbers. Python uses a fixed number of bytes (8 bytes) to represent floats. Therefore, it can represent some numbers in binary approximately. Use the isclose() function from the math module to test equality for floating-point numbers. I hope you got a clear idea about float in Python. To continue your Python learning Journey, follow Publish Square blog. Share it with your friends and express your thoughts in the comments section