Truncate Float en Python : expliqué avec des exemples

Tronquer un nombre à virgule flottante en Python est une opération courante que de nombreux programmeurs rencontrent dans diverses applications. Le processus consiste à supprimer la décimale d'un flottant, ne laissant que la partie entière. Il s'agit d'une technique précieuse pour simplifier les calculs, améliorer la lisibilité des résultats et réduire les erreurs d'arrondi potentielles.

Pour tronquer les valeurs flottantes en Python, vous pouvez utiliser la fonction math.trunc(), le module décimal ou la manipulation de chaîne. En utilisant ces techniques, les développeurs Python peuvent adapter le processus de troncation à leurs besoins spécifiques avec flexibilité et précision.

Dans cet article, nous allons explorer comment la troncature peut être appliquée dans la programmation Python pour créer un code plus efficace et rationalisé . Nous plongerons dans divers exemples pratiques, présentant un aperçu complet de la façon d'utiliser cette technique pour un effet maximal.

Commençons par examiner les concepts et techniques fondamentaux pour tronquer les chaînes, les nombres et les structures de données en Python.

Table des matières

• Principes de base de Python Truncate
  • 1. Définition de Truncate en Python
  • 2. Comment utiliser la fonction Python Truncate
  • 3. Comment tronquer les décimales et les flottants en Python
• Tronquer en Python à l'aide de la bibliothèque mathématique et des fonctions
  • 1. math.trunc()
  • 2. math.floor() et math.ceil()
  • 3. Conversion de valeur flottante à l'aide de int ()
• Comment tronquer des valeurs en Python avec le module décimal
  • 1. Utilisation de la méthode de quantification
  • 2. Utilisation de la méthode to_integral_value
  • 3. Application de la méthode de normalisation
• Techniques de troncature pour les chaînes et les listes en Python
  • 1. Techniques de troncature de chaîne
  • 2. Troncation de la liste
• Comment utiliser NumPy et pandas pour tronquer des valeurs en Python
  • 1. Troncation en Python avec NumPy
  • 2. Utilisation de DataFrame et Loc pour la troncature en Python
• 3 applications pratiques de la troncature en Python
• Comparaison des méthodes de troncation en Python
• Choisir la méthode de troncature appropriée
• Dernières pensées

Principes de base de Python Truncate

Dans cette section, nous couvrirons la définition de la troncature, examinerons les fonctions Python pour la troncature et apprendrons à tronquer les décimales et les flottants.

1. Définition de Truncate en Python

Tronquer est un processus de raccourcissement d'un nombre en supprimant la décimale. C'est un concept important en informatique et en mathématiques et il est utilisé pour réduire les chiffres à une forme plus simple sans altérer leur valeur.

2. Comment utiliser la fonction Python Truncate

Il existe plusieurs façons de tronquer les valeurs absolues en Python. Une méthode courante pour obtenir une troncature consiste à utiliser la fonction math.trunc() , qui supprime directement les décimales d'une valeur binaire à virgule flottante.

Voici un exemple :

import math

float1 = 123.356
float2 = -2434.545

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

Sortir:

123
-2434

Cette méthode donne des résultats similaires à la fonction int() , qui tronque également le nombre donné en supprimant les décimales.

3. Comment tronquer les décimales et les flottants en Python

Dans certains cas, vous devrez peut-être tronquer un flottant à un nombre spécifique de chiffres décimaux. La fonction round() peut être utilisée pour arrondir les nombres dans de tels cas. Cependant, veuillez noter que la fonction round() ne fait qu'arrondir le nombre plutôt que de le tronquer.

Si vous souhaitez tronquer à un point décimal spécifique, vous pouvez utiliser l'approche suivante :

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)

Sortir:

3.14

Dans l'exemple ci-dessus, la fonction truncate_float() prend deux paramètres — le nombre flottant à tronquer et le nombre de décimales souhaité.

Il utilise un multiplicateur pour d'abord décaler la virgule décimale du flottant, puis convertit le résultat en un entier (tronquant effectivement le nombre), et enfin divise l'entier par le multiplicateur pour restaurer la virgule décimale à sa position d'origine.

Gardez à l'esprit que travailler avec des flottants en Python peut entraîner une certaine imprécision dans les calculs en raison de la nature de l'arithmétique en virgule flottante. Par conséquent, lorsque l'exactitude et la précision sont cruciales, envisagez d'utiliser le module décimal .

D'accord, c'est la base de la façon de tronquer les valeurs en Python. Dans la section suivante, nous verrons comment tronquer des valeurs à l'aide de la bibliothèque mathématique et d'autres fonctions Python.

Tronquer en Python à l'aide de la bibliothèque mathématique et des fonctions

Dans le domaine de la programmation Python, l'optimisation est souvent la clé. L'utilisation de la bibliothèque "math" de Python et de ses fonctions intégrées peut améliorer considérablement les performances, en particulier lorsqu'il s'agit de grands ensembles de données ou de calculs complexes.

Cette section est consacrée à l'exploration de la manière dont nous pouvons utiliser la bibliothèque "math" et ses fonctionnalités robustes pour les tâches de troncature - réduisant ou limitant efficacement la taille des données - en Python.

1. math.trunc()

La bibliothèque mathématique Python fournit plusieurs fonctions pour travailler avec des valeurs flottantes, dont l'une est math.trunc() . Cette fonction renvoie la valeur tronquée d'un flottant donné, supprimant effectivement sa partie fractionnaire et ne laissant que la partie entière.

Voici un exemple d'utilisation de math.trunc() :

import math

number = 3.7
truncated_number = math.trunc(number)

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

Sortir:

3
3.7

math.trunc() arrondit le nombre vers zéro. Pour les nombres positifs, cela fonctionne comme la fonction de plancher, et pour les nombres négatifs, cela fonctionne comme la fonction de plafond.

2. math.floor() et math.ceil()

En plus de math.trunc() , la bibliothèque mathématique fournit également des fonctions pour arrondir les nombres de différentes manières, telles que les fonctions math.floor() et math.ceil() .

La fonction math.floor() arrondit les valeurs à virgule flottante à l'entier le plus proche, tandis que math.ceil() arrondit à l'entier le plus proche.

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) 

Sortir:

Floor of x: 3
Floor of y: 9

Voici une illustration de la fonction math.floor()

Cet extrait de code illustre l'utilisation de la fonction 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) 

Sortir:

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

3. Conversion de valeur flottante à l'aide de int ()

Une autre façon de tronquer une valeur flottante consiste à utiliser la fonction intégrée int() . Lorsqu'il est passé dans un flottant, il le convertit en entier en tronquant la partie décimale.

Cette approche peut être plus pratique pour les cas de troncature simple, car elle ne nécessite pas l'importation de la bibliothèque mathématique.

float5 = 7.65
float6 = -3.14

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

Sortir:

7
-3

Cependant, il est essentiel de se rappeler que la fonction int() n'est pas équivalente à math.floor() ou math.ceil() , car elle ne fait que tronquer le nombre sans tenir compte de son signe.

Voici l'illustration de la fonction int() ci-dessus pour une troncature flottante dans un éditeur de code ;

En résumé, la bibliothèque mathématique Python offre plusieurs fonctions pour travailler avec des valeurs flottantes, notamment la troncature, l'arrondi vers le bas et l'arrondi vers le haut. La bibliothèque mathématique est un outil essentiel sur lequel s'appuyer lorsque vous devez effectuer des opérations mathématiques avancées.

Alors que les fonctions int () et math.trunc () offrent des moyens simples de tronquer les valeurs à virgule flottante, le module decimal fournit une approche plus puissante et précise, alors explorons cela dans la section suivante.

Comment tronquer des valeurs en Python avec le module décimal

Le module 'decimal' de Python est un outil puissant qui offre une gestion précise des nombres décimaux, une fonctionnalité particulièrement pratique lorsque la troncature est nécessaire.

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. Calculs financiers : lorsque vous travaillez avec des devises, il est courant de tronquer les valeurs décimales pour représenter l'argent réel où seuls les cents sont pris en compte et les unités plus petites ne sont pas pertinentes.

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

Sortir:

49.98

2. Agrégation de données : La troncature peut également être utilisée pour agréger des données selon un critère spécifique. Par exemple, agréger la valeur moyenne des relevés de température quotidiens en fonction de valeurs entières.

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)

Sortir:

23.142857142857142

3. Ordonner les éléments : Parfois, les éléments doivent être ordonnés en fonction d'une règle de troncature spécifique. Ceci peut être réalisé en utilisant le paramètre key dans la fonction triée() de 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)

Sortir:

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

Ces applications réelles de la troncature montrent qu'elle est inestimable dans divers domaines, tels que l'analyse de données et l'apprentissage automatique.

Pourtant, une question importante se pose : comment se comparent les techniques de troncature et quelle méthode devez-vous utiliser pour un scénario donné ? Pour y répondre, notre prochaine section se plongera dans une analyse comparative des différentes méthodes de troncature dont nous avons discuté.

Comparaison des méthodes de troncation en Python

Pour comparer les différentes méthodes de troncature en termes de performances et de précision, considérons un grand ensemble de données et mesurons le temps d'exécution pour chaque approche.

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

Dans cet exemple, un ensemble de données d'un million de valeurs à virgule flottante aléatoires entre 0 et 1000 est généré. Le temps d'exécution de chaque méthode de troncature est mesuré à l'aide du module de temps. L'approche du module décimal convertit chaque nombre en une instance Decimal avant de le tronquer pour garantir des résultats précis.

En exécutant le code, vous pouvez observer les temps d'exécution de chaque méthode et effectuer une comparaison des performances.

Choisir la méthode de troncature appropriée

Lorsqu'il s'agit de tronquer des valeurs à virgule flottante en Python, le choix de la méthode appropriée dépend des exigences spécifiques de l'application ou du cas d'utilisation.

Tenez compte des facteurs suivants lorsque vous décidez de la méthode à utiliser :

• Précision : si la précision est de la plus haute importance et que vous avez besoin d'un contrôle précis des décimales, le module décimal offre le plus haut niveau de précision.

• Performance : Pour une troncature simple sans besoin de haute précision, la fonction int() et la fonction math.trunc() offrent des solutions efficaces.

• Comportement d'arrondi : selon le comportement d'arrondi souhaité, le module décimal vous permet de spécifier différents modes d'arrondi, tels que ROUND_DOWN , ROUND_UP , ROUND_HALF_UP , etc.

• Compatibilité : si vous devez garantir la compatibilité avec le code hérité ou les systèmes qui ne prennent pas en charge le module décimal, la fonction int() ou la fonction math.trunc peuvent être des options viables.

Dernières pensées

Comprendre les bases de la troncation des valeurs flottantes en Python est essentiel pour une manipulation et une analyse précises des données. Python fournit diverses méthodes et fonctions pour tronquer ou arrondir les nombres à virgule flottante en fonction d'exigences spécifiques.

En utilisant les fonctions intégrées telles que math.trunc() , math.floor() et math.ceil() , nous pouvons effectuer efficacement des opérations de troncature. Ces fonctions offrent une flexibilité dans la gestion des valeurs flottantes positives et négatives, ce qui nous permet de contrôler le résultat souhaité.

De plus, le module décimal offre un meilleur contrôle sur l'arrondi et la précision, ce qui le rend adapté aux calculs financiers ou aux situations où la précision est primordiale.

Comme pour tout concept de programmation, la pratique et l'expérimentation sont essentielles pour maîtriser l'art de tronquer les valeurs flottantes. Allez-y et appliquez ces techniques dans des scénarios réels et explorez des ressources supplémentaires, telles que la documentation Python et les forums communautaires, pour améliorer votre compréhension et vos compétences !