Truncate Float em Python: explicado com exemplos

Truncar um número de ponto flutuante em Python é uma operação comum que muitos programadores encontram em vários aplicativos. O processo envolve remover a casa decimal de um float, deixando apenas a parte inteira. É uma técnica valiosa para simplificar cálculos, melhorar a legibilidade na saída e reduzir possíveis erros de arredondamento.

Para truncar valores float em Python, você pode usar a função math.trunc(), módulo decimal ou manipulação de string. Usando essas técnicas, os desenvolvedores Python podem adaptar o processo de truncamento aos seus requisitos específicos com flexibilidade e precisão.

Neste artigo, exploraremos como o truncamento pode ser aplicado na programação Python para criar um código mais eficiente e simplificado . Vamos nos aprofundar em vários exemplos práticos, apresentando uma visão abrangente de como empregar essa técnica para obter o máximo efeito.

Vamos começar examinando os conceitos e técnicas fundamentais para truncar strings, números e estruturas de dados em Python.

Índice

• Noções básicas de truncamento do Python
  • 1. Definição de truncar em Python
  • 2. Como usar a função de truncamento do Python
  • 3. Como truncar casas decimais e floats em Python
• Truncando em Python usando funções e biblioteca de matemática
  • 1. math.trunc()
  • 2. math.floor() e math.ceil()
  • 3. Conversão de valor flutuante usando int()
• Como truncar valores em Python com o módulo decimal
  • 1. Usando o Método de Quantização
  • 2. Usando o Método to_integral_value
  • 3. Aplicando o Método Normalize
• Técnicas de Truncamento para Strings e Listas em Python
  • 1. Técnicas de truncamento de strings
  • 2. Truncamento de lista
• Como usar NumPy e pandas para truncar valores em Python
  • 1. Truncamento em Python usando NumPy
  • 2. Usando DataFrame e Loc para truncamento em Python
• 3 Aplicações Práticas de Truncamento em Python
• Comparando métodos de truncamento em Python
• Escolhendo o método de truncamento apropriado
• Pensamentos finais

Noções básicas de truncamento do Python

Nesta seção, abordaremos a definição de truncamento, examinaremos as funções do Python para truncamento e aprenderemos como truncar casas decimais e flutuantes.

1. Definição de truncar em Python

Truncar é um processo de encurtar um número removendo a casa decimal. É um conceito importante em ciência da computação e matemática e é usado para reduzir dígitos a uma forma mais simples sem alterar seu valor.

2. Como usar a função de truncamento do Python

Existem várias maneiras de truncar valores absolutos em Python. Um método comum para obter o truncamento é usar a função math.trunc() , que remove diretamente as casas decimais de um valor de ponto flutuante binário.

Aqui está um exemplo:

import math

float1 = 123.356
float2 = -2434.545

print(math.trunc(float1))  
print(math.trunc(float2))  

Saída:

123
-2434

Esse método fornece resultados semelhantes aos da função int() , que também trunca o número fornecido removendo as casas decimais.

3. Como truncar casas decimais e floats em Python

Em alguns casos, pode ser necessário truncar um float para um número específico de dígitos decimais. A função round() pode ser usada para arredondar números nesses casos. No entanto, observe que a função round() apenas arredonda o número em vez de truncá-lo.

Se você deseja truncar para um ponto decimal específico, pode usar a seguinte abordagem:

def truncate_float(float_number, decimal_places):
    multiplier = 10 ** decimal_places
    return int(float_number * multiplier) / multiplier

float3 = 3.14159
result = truncate_float(float3, 2)

print(result)

Saída:

3.14

No exemplo acima, a função truncate_float() recebe dois parâmetros — o número float a ser truncado e o número desejado de casas decimais.

Ele usa um multiplicador para primeiro deslocar o ponto decimal do float, depois converte o resultado em um número inteiro (efetivamente truncando o número) e finalmente divide o inteiro pelo multiplicador para restaurar o ponto decimal à sua posição original.

Tenha em mente que trabalhar com floats em Python pode levar a alguma imprecisão nos cálculos devido à natureza da aritmética de ponto flutuante. Portanto, quando exatidão e precisão forem cruciais, considere o uso do módulo decimal .

Tudo bem, esse é o básico de como truncar valores em Python. Na próxima seção, veremos como você pode truncar valores usando a biblioteca matemática e outras funções do Python.

Truncando em Python usando funções e biblioteca de matemática

No domínio da programação Python, a otimização geralmente é fundamental. Usar a biblioteca 'math' do Python e suas funções integradas pode melhorar significativamente o desempenho, principalmente ao lidar com grandes conjuntos de dados ou cálculos complexos.

Esta seção é dedicada a explorar como podemos utilizar a biblioteca 'math' e suas funcionalidades robustas para tarefas de truncamento — reduzindo ou limitando com eficiência o tamanho dos dados — em Python.

1. math.trunc()

A biblioteca matemática do Python fornece várias funções para trabalhar com valores flutuantes, uma das quais é math.trunc() . Esta função retorna o valor truncado de um float dado, efetivamente removendo sua parte fracionária e deixando apenas a parte inteira.

Aqui está um exemplo de como usar math.trunc() :

import math

number = 3.7
truncated_number = math.trunc(number)

print("Original number:", number)
print("Truncated number:", truncated_number)

Saída:

3
3.7

math.trunc() arredonda o número para zero. Para números positivos, funciona como a função do piso e, para números negativos, funciona como a função do teto.

2. math.floor() e math.ceil()

Além de math.trunc() , a biblioteca math também fornece funções para arredondar números de diferentes maneiras, como as funções math.floor() e math.ceil() .

A função math.floor() arredonda para baixo os valores de ponto flutuante para o inteiro mais próximo, enquanto math.ceil() arredonda para o inteiro mais próximo.

import math

# Example using math.floor() function
x = 3.7
y = 9.2

floor_x = math.floor(x)
floor_y = math.floor(y)

print("Floor of x:", floor_x) 
print("Floor of y:", floor_y) 

Saída:

Floor of x: 3
Floor of y: 9

Aqui está uma ilustração da função math.floor()

Este trecho de código demonstra o uso da função math.ceil() :

import math

# Example usage of math.ceil()
x = 3.7
y = 9.2
z = -4.5

ceil_x = math.ceil(x)
ceil_y = math.ceil(y)
ceil_z = math.ceil(z)

# Output the results
print("Ceiling of", x, "is", ceil_x)
print("Ceiling of", y, "is", ceil_y)
print("Ceiling of", z, "is", ceil_z) 

Saída:

Ceiling of 3.7 is 4
Ceiling of 9.2 is 10
Ceiling of -4.5 is -4

3. Conversão de valor flutuante usando int()

Outra maneira de truncar um valor float é usando a função interna int() . Quando passado em float, ele irá convertê-lo em um inteiro truncando a parte decimal.

Essa abordagem pode ser mais conveniente para casos de truncamento simples, pois não requer a importação da biblioteca matemática.

float5 = 7.65
float6 = -3.14

print(int(float5)) 
print(int(float6)) 

Saída:

7
-3

No entanto, é importante lembrar que a função int() não é equivalente a math.floor() ou math.ceil() , pois apenas trunca o número sem considerar seu sinal.

Aqui está a ilustração da função int() acima para um truncamento float em um editor de código;

Em resumo, a biblioteca matemática do Python oferece várias funções para trabalhar com valores flutuantes, incluindo truncamento, arredondamento para baixo e arredondamento para cima. A biblioteca de matemática é uma ferramenta essencial para confiar quando você precisa realizar operações matemáticas avançadas.

Enquanto as funções int() e math.trunc() oferecem maneiras simples de truncar valores de ponto flutuante, o módulo decimal fornece uma abordagem mais poderosa e precisa, então vamos explorar isso na próxima seção.

Como truncar valores em Python com o módulo decimal

O módulo 'decimal' do Python é uma ferramenta poderosa que oferece tratamento preciso de números decimais, um recurso que é particularmente útil quando o truncamento é necessário.

This section dives into the practical applications of this module for truncating values in Python. We’ll explore step-by-step examples and provide an in-depth understanding of the concepts behind this effective and precise data manipulation technique.

1. Using the Quantize Method

The quantize method of the Decimal class is a versatile tool for truncating decimal instances. This method allows developers to set the desired precision and rounding mode, ensuring accurate truncation.

Consider the following example:

from decimal import Decimal, ROUND_DOWN 
number = Decimal('3.14159') 
truncated = number.quantize(Decimal('1.'), rounding=ROUND_DOWN) print(truncated)

Output:

3

In this example, the quantize method is applied to the Decimal instance number with a precision of one decimal place and the ROUND_DOWN rounding mode, which effectively truncates the value.

2. Using the to_integral_value Method

Another useful method provided by the Decimal class is to_integral_value. This method returns the nearest integer to the given decimal value, effectively truncating the decimal places.

The to_integral_value method allows developers to specify the rounding mode as well.

Here’s an example:

from decimal import Decimal, ROUND_DOWN 
number = Decimal('3.14159') 
truncated = number.to_integral_value(rounding=ROUND_DOWN) print(truncated)

Output:

3

In this example, the to_integral_value method is used with the ROUND_DOWN rounding mode, resulting in truncation.

3. Applying the Normalize Method

The normalize method of the Decimal class provides a way to adjust the exponent and scale of a decimal instance. By using this method, developers can effectively truncate the decimal places.

Consider the following example:

from decimal import Decimal 
number = Decimal('3.14159') 
truncated = number.normalize() 
print(truncated)

Output:

3.14159

In this example, the normalize method is applied to the Decimal instance number, resulting in the same value without any decimal places.

Next, let’s look at ways you can truncate strings and lists in Python.

Truncation Techniques for Strings and Lists in Python

In this section, we’ll discuss various techniques for truncating strings and lists in Python functions. We’ll cover the following sub-sections: string truncate techniques and list truncation.

1. String Truncate Techniques

There are multiple ways to truncate a string in Python, including the use of str.format, slicing, and f-strings.

1) Using str.format: This method allows you to truncate a string by specifying a precision value. For example:

truncated_string = '{:.5}'.format('aaabbbccc')
print(truncated_string) 

Output:

aaabb

2) Using slicing: By using slice notation, you can select a substring of the original string. For example:

my_string = 'aaabbbccc'
truncated_string = my_string[:5]
print(truncated_string)

Output:

aaabb

3) Using f-strings: With f-strings, the truncation can be performed inline within the string. For example:

my_string = 'aaabbbccc'
truncated_string = f'{my_string[:5]}'
print(truncated_string)

Output:

aaabb

2. List Truncation

There are several ways to truncate lists in Python, such as slicing and using list comprehensions.

1) Using slicing: Slicing allows you to select a range of elements in a list. For example:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
truncated_list = my_list[:5]
print(truncated_list)

Output:

[1, 2, 3, 4, 5]

2) Using list comprehensions: List comprehensions allow you to create a new list by iterating over an existing list and applying a condition or operation. For example, to truncate tuples in a list:

my_list = [('apple', 3), ('orange', 5), ('banana', 2)]
truncated_list = [(fruit, count) for fruit, count in my_list if count < 5]
print(truncated_list)

Output:

[('apple', 3), ('banana', 2)]

Now that we’ve covered the various techniques for truncating strings and lists using Python, let’s take a look at how you can do the same using libraries like NumPy and pandas.

How to Use NumPy and pandas to Truncate Values in Python

When it comes to numerical and data analysis in Python, the names ‘NumPy’ and ‘pandas’ undoubtedly resonate among developers. These powerful libraries have transformed the landscape of data manipulation by providing extensive functionality for array processing, data handling, and much more.

In this section, we’ll explore common ways to truncate elements in Python using NumPy and pandas DataFrames.

1. Truncation in Python Using NumPy

NumPy offers a simple, built-in function called trunc which allows you to truncate values to the nearest whole number.

The trunc function eliminates the fractional part of the input, returning only the integer.

import numpy as np

values = np.array([1.234, 5.678, 9.012])
truncated_values = np.trunc(values)
print(truncated_values)

Output:

array([1., 5., 9.])

Here are some key points about the trunc function:

• It works element-wise, meaning it can truncate each element in an array or a list.

• The data type (dtype) of the output array will be the same as the input array.

• The function can be applied to different data structures, such as lists, tuples, or arrays, as long as the elements are numeric.

2. Using DataFrame and Loc for Truncation in Python

Pandas DataFrame is a powerful, flexible data structure for handling large, structured datasets. You can use the DataFrame.truncate() function to truncate a DataFrame based on the index.

To see a practical demonstration of how to load datasets in Python, watch this YouTube video:

Alternatively, you can use the loc property to filter rows or columns based on a specific condition.

import pandas as pd

data = {'A': [1.234, 5.678, 9.012], 'B': [4.567, 8.901, 2.345]}
df = pd.DataFrame(data)

# Truncating based on the index
truncated_df = df.truncate(before=1, after=2)
print(truncated_df)

Output:

       A      B
1  5.678  8.901
2  9.012  2.345

Using loc and a condition, we can achieve truncation based on values as well:

# Condition to truncate values in column 'A'
condition = (df['A'] < 6)

# Truncating DataFrame based on condition
truncated_df = df.loc[condition]
print(truncated_df)

Output:

       A      B
0  1.234  4.567
1  5.678  8.901

In this example, a boolean condition was used to filter out rows in the DataFrame. Depending on your use case, you can apply different conditions and operations using loc.

Let’s now look at the practical applications of truncation in Python.

3 Practical Applications of Truncation in Python

Understanding the concept of truncation in Python and its corresponding techniques is only half of the equation. The other half involves applying this knowledge effectively in practical scenarios.

In this section, we transition from theory to practice, illustrating how truncation can be used to optimize Python code in real-world applications.

Truncation is useful in various applications, some of which are:

1. Cálculos financeiros : Ao trabalhar com moedas, é comum truncar valores decimais para representar dinheiro real, onde apenas centavos são considerados e unidades menores não são relevantes.

price = 49.987
truncated_price = int(price * 100) / 100
print(truncated_price)

Saída:

49.98

2. Agregação de dados : O truncamento também pode ser usado para agregar dados de acordo com um critério específico. Por exemplo, agregando o valor médio das leituras diárias de temperatura com base em valores inteiros.

temperature_data = [22.3, 23.9, 24.8, 23.4, 22.7, 24.1, 24.6]
truncated_temperature = [int(temp) for temp in temperature_data]
mean_temperature = sum(truncated_temperature) / len(truncated_temperature)
print(mean_temperature)

Saída:

23.142857142857142

3. Ordenação dos elementos : Às vezes, os elementos precisam ser ordenados com base em uma regra de truncamento específica. Isso pode ser feito usando o parâmetro key na função sorted() do Python .

data = [4.8, 3.2, 2.9, 7.5, 6.1, 9.0, 1.5]
sorted_data = sorted(data, key=lambda x: int(x))
print(sorted_data)

Saída:

[1.5, 2.9, 3.2, 4.8, 6.1, 7.5, 9.0]

Essas aplicações de truncamento no mundo real são inestimáveis ​​em vários campos, como análise de dados e aprendizado de máquina.

No entanto, surge uma questão importante: como comparar as técnicas de truncamento e qual método você deve usar para um determinado cenário? Para responder a isso, nossa próxima seção mergulhará em uma análise comparativa dos vários métodos de truncamento que discutimos.

Comparando métodos de truncamento em Python

Para comparar os diferentes métodos de truncamento em termos de desempenho e precisão, vamos considerar um grande conjunto de dados e medir o tempo de execução de cada abordagem.

import random
import time
from decimal import Decimal, ROUND_DOWN
import math

# Generate a large dataset of floating-point values
data = [random.uniform(0, 1000) for _ in range(10**6)]

# Using int function
start_time = time.time()
truncated_int = [int(number) for number in data]
int_execution_time = time.time() - start_time

# Using math.trunc function
start_time = time.time()
truncated_math = [math.trunc(number) for number in data]
math_execution_time = time.time() - start_time

# Using decimal module
start_time = time.time()
truncated_decimal = [Decimal(str(number)).quantize(Decimal('1.'), rounding=ROUND_DOWN) for number in data]
decimal_execution_time = time.time() - start_time

print(f"Execution time using int function: {int_execution_time:.5f} seconds")
print(f"Execution time using math.trunc function: {math_execution_time:.5f} seconds")
print(f"Execution time using decimal module: {decimal_execution_time:.5f} seconds")

Neste exemplo, um conjunto de dados de um milhão de valores aleatórios de ponto flutuante entre 0 e 1000 é gerado. O tempo de execução para cada método de truncamento é medido usando o módulo de tempo. A abordagem do módulo decimal converte cada número em uma instância Decimal antes de truncar para garantir resultados precisos.

Ao executar o código, você pode observar os tempos de execução de cada método e fazer uma comparação de desempenho.

Escolhendo o método de truncamento apropriado

Quando se trata de truncar valores de ponto flutuante em Python, a escolha do método apropriado depende dos requisitos específicos do aplicativo ou caso de uso.

Considere os seguintes fatores ao decidir qual método usar:

• Precisão: Se a precisão for de extrema importância e você precisar de um controle preciso sobre as casas decimais, o módulo decimal fornece o mais alto nível de precisão.

• Desempenho: Para truncamento simples sem a necessidade de alta precisão, as funções int() e math.trunc() oferecem soluções eficientes.

• Comportamento de arredondamento: Dependendo do comportamento de arredondamento desejado, o módulo decimal permite especificar vários modos de arredondamento, como ROUND_DOWN , ROUND_UP , ROUND_HALF_UP e mais.

• Compatibilidade: Se você precisa garantir compatibilidade com código legado ou sistemas que não suportam o módulo decimal, a função int() ou a função math.trunc podem ser opções viáveis.

Pensamentos finais

Compreender os fundamentos do truncamento de valores flutuantes em Python é essencial para manipulação e análise precisas de dados. O Python fornece vários métodos e funções para truncar ou arredondar números de ponto flutuante com base em requisitos específicos.

Usando as funções integradas como math.trunc() , math.floor() e math.ceil() , podemos realizar operações de truncamento de forma eficaz. Essas funções oferecem flexibilidade para lidar com valores flutuantes positivos e negativos, permitindo controlar o resultado desejado.

Além disso, o módulo decimal oferece melhor controle sobre arredondamento e precisão, tornando-o adequado para cálculos financeiros ou situações em que a precisão é fundamental.

Como em qualquer conceito de programação, a prática e a experimentação são essenciais para dominar a arte de truncar valores flutuantes. Vá em frente e aplique essas técnicas em cenários do mundo real e explore recursos adicionais, como documentação do Python e fóruns da comunidade, para aprimorar sua compreensão e proficiência!