Truncate Float in Python: uitgelegd met voorbeelden

Het afkappen van een getal met drijvende komma in Python is een veelvoorkomende bewerking die veel programmeurs in verschillende toepassingen tegenkomen. Het proces omvat het verwijderen van de komma van een float, waardoor alleen het gehele deel overblijft. Het is een waardevolle techniek om berekeningen te vereenvoudigen, de leesbaarheid van de uitvoer te verbeteren en mogelijke afrondingsfouten te verminderen.

Om float-waarden in Python af te kappen, kunt u de functie math.trunc(), decimale module of tekenreeksmanipulatie gebruiken. Met behulp van deze technieken kunnen Python-ontwikkelaars het truncatieproces met flexibiliteit en precisie afstemmen op hun specifieke vereisten.

In dit artikel zullen we onderzoeken hoe afkappen kan worden toegepast binnen Python-programmering om efficiëntere en gestroomlijnde code te creëren . We gaan dieper in op verschillende praktische voorbeelden en geven een uitgebreide kijk op hoe je deze techniek kunt gebruiken voor een maximaal effect.

Laten we beginnen met te kijken naar de fundamentele concepten en technieken voor het afkappen van strings, getallen en datastructuren in Python.

Inhoudsopgave

• Basisprincipes van Python Truncate
  • 1. Definitie van Truncate in Python
  • 2. Hoe de Python Truncate-functie te gebruiken
  • 3. Hoe decimalen en drijvers in Python af te kappen
• Afkappen in Python met behulp van wiskundige bibliotheek en functies
  • 1. wiskunde.trunc()
  • 2. wiskunde.vloer() en wiskunde.ceil()
  • 3. Drijvende waardeconversie met behulp van int()
• Waarden afkappen in Python met de decimale module
  • 1. De Quantize-methode gebruiken
  • 2. De to_integral_value-methode gebruiken
  • 3. De normalisatiemethode toepassen
• Truncatietechnieken voor strings en lijsten in Python
  • 1. String Truncate-technieken
  • 2. Lijstafkapping
• Hoe NumPy en panda's te gebruiken om waarden in Python af te kappen
  • 1. Truncatie in Python met behulp van NumPy
  • 2. DataFrame en Loc gebruiken voor afkappen in Python
• 3 praktische toepassingen van afkappen in Python
• Truncatiemethoden vergelijken in Python
• De juiste afkapmethode kiezen
• Laatste gedachten

Basisprincipes van Python Truncate

In deze sectie behandelen we de definitie van truncatie, kijken we naar Python-functies voor truncatie en leren we hoe u decimalen en floats kunt afkappen.

1. Definitie van Truncate in Python

Truncate is een proces waarbij een getal wordt verkort door de decimale plaats te verwijderen. Het is een belangrijk concept in de informatica en wiskunde en wordt gebruikt om cijfers terug te brengen tot een eenvoudigere vorm zonder hun waarde te veranderen.

2. Hoe de Python Truncate-functie te gebruiken

Er zijn verschillende manieren om absolute waarden in Python af te kappen. Een veelgebruikte methode om afkapping te bereiken, is door de functie math.trunc() te gebruiken , die de decimalen direct verwijdert uit een binaire drijvende-kommawaarde.

Hier is een voorbeeld:

import math

float1 = 123.356
float2 = -2434.545

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

Uitgang:

123
-2434

Deze methode geeft vergelijkbare resultaten als de functie int() , die ook het opgegeven getal afkapt door de decimalen te verwijderen.

3. Hoe decimalen en drijvers in Python af te kappen

In sommige gevallen kan het zijn dat u een float moet afkappen tot een bepaald aantal decimalen. De functie round() kan in dergelijke gevallen worden gebruikt om getallen af ​​te ronden. Houd er echter rekening mee dat de functie round() het getal alleen afrondt in plaats van af te kappen.

Als u wilt afkappen tot een bepaald decimaalteken, kunt u de volgende aanpak gebruiken:

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)

Uitgang:

3.14

In het bovenstaande voorbeeld heeft de functie truncate_float() twee parameters nodig: het floatnummer dat moet worden afgekapt en het gewenste aantal decimalen.

Het gebruikt een vermenigvuldiger om eerst de komma van de vlotter te verschuiven, converteert vervolgens het resultaat naar een geheel getal (waardoor het getal effectief wordt afgekapt) en deelt ten slotte het gehele getal door de vermenigvuldiger om de komma naar zijn oorspronkelijke positie te herstellen.

Houd er rekening mee dat het werken met drijvers in Python kan leiden tot enige onnauwkeurigheid in berekeningen vanwege de aard van drijvende-kommaberekeningen. Overweeg daarom, wanneer nauwkeurigheid en precisie cruciaal zijn, om de decimale module te gebruiken.

Oké, dat zijn de basisprincipes van het afkappen van waarden in Python. In het volgende gedeelte bekijken we hoe u waarden kunt afkappen met behulp van de wiskundebibliotheek en andere Python-functies.

Afkappen in Python met behulp van wiskundige bibliotheek en functies

Op het gebied van Python-programmering is optimalisatie vaak de sleutel. Het gebruik van de 'math'-bibliotheek van Python en de ingebouwde functies kan de prestaties aanzienlijk verbeteren, vooral bij het omgaan met grote datasets of complexe berekeningen.

Deze sectie is gewijd aan het onderzoeken hoe we de 'math'-bibliotheek en zijn robuuste functionaliteiten kunnen gebruiken voor truncatietaken - het efficiënt verkleinen of beperken van de gegevensgrootte - in Python.

1. wiskunde.trunc()

De wiskundebibliotheek van Python biedt verschillende functies om met zwevende waarden te werken, een daarvan is math.trunc() . Deze functie retourneert de afgekapte waarde van een gegeven float, waarbij effectief het fractionele deel wordt verwijderd en alleen het gehele deel overblijft.

Hier is een voorbeeld van het gebruik van math.trunc() :

import math

number = 3.7
truncated_number = math.trunc(number)

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

Uitgang:

3
3.7

math.trunc() rondt het getal af naar nul. Voor positieve getallen werkt het als de vloerfunctie en voor negatieve getallen werkt het als de plafondfunctie.

2. wiskunde.vloer() en wiskunde.ceil()

Naast math.trunc() biedt de wiskundebibliotheek ook functies voor het op verschillende manieren afronden van getallen, zoals de functies math.floor() en math.ceil() .

De functie math.floor() rondt drijvende-kommawaarden naar beneden af ​​op het dichtstbijzijnde gehele getal, terwijl math.ceil() naar boven afrondt op het dichtstbijzijnde gehele getal.

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) 

Uitgang:

Floor of x: 3
Floor of y: 9

Hier is een illustratie van de functie math.floor().

Dit codefragment demonstreert het gebruik van de functie 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) 

Uitgang:

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

3. Drijvende waardeconversie met behulp van int()

Een andere manier om een ​​float-waarde af te kappen, is door de ingebouwde functie int() te gebruiken . Als het in een float wordt doorgegeven, converteert het het naar een geheel getal door het decimale deel af te kappen.

Deze aanpak kan handiger zijn voor eenvoudige gevallen van afkappen, omdat de wiskundebibliotheek niet hoeft te worden geïmporteerd.

float5 = 7.65
float6 = -3.14

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

Uitgang:

7
-3

Het is echter essentieel om te onthouden dat de functie int() niet gelijk is aan math.floor() of math.ceil() , omdat het getal alleen wordt afgekapt zonder rekening te houden met het teken.

Hier is de illustratie van de bovenstaande functie int() voor een float-truncatie in een code-editor;

Samenvattend biedt de wiskundebibliotheek van Python meerdere functies om met zwevende waarden te werken, waaronder afkappen, naar beneden afronden en naar boven afronden. De wiskundebibliotheek is een essentieel hulpmiddel waarop u kunt vertrouwen wanneer u geavanceerde wiskundige bewerkingen moet uitvoeren.

Hoewel de functies int() en math.trunc() eenvoudige manieren bieden om drijvende-kommawaarden af ​​te kappen, biedt de decimale module een krachtigere en preciezere benadering, dus laten we dat in de volgende sectie onderzoeken.

Waarden afkappen in Python met de decimale module

De 'decimale' module van Python is een krachtige tool die nauwkeurige verwerking van decimale getallen mogelijk maakt, een functie die vooral handig is wanneer afkappen nodig is.

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. Financiële berekeningen : bij het werken met valuta's is het gebruikelijk om decimale waarden af ​​te kappen om echt geld weer te geven, waarbij alleen centen in aanmerking worden genomen en kleinere eenheden niet relevant zijn.

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

Uitgang:

49.98

2. Gegevensaggregatie : afkappen kan ook worden gebruikt om gegevens volgens een specifiek criterium te aggregeren. Bijvoorbeeld het optellen van de gemiddelde waarde van dagelijkse temperatuurmetingen op basis van gehele waarden.

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)

Uitgang:

23.142857142857142

3. Elementen ordenen : soms moeten elementen worden geordend op basis van een specifieke afbreekregel. Dit kan worden bereikt door de parameter key te gebruiken in de functie sorted() van 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)

Uitgang:

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

Deze real-world toepassingen van truncatie laten zien dat het van onschatbare waarde is op verschillende gebieden, zoals data-analyse en machine learning.

Toch rijst een belangrijke vraag: hoe verhouden truncatietechnieken zich tot elkaar en welke methode moet u gebruiken voor een bepaald scenario? Om dit te beantwoorden, zal onze volgende sectie ingaan op een vergelijkende analyse van de verschillende inkortingsmethoden die we hebben besproken.

Truncatiemethoden vergelijken in Python

Laten we, om de verschillende truncatiemethoden te vergelijken wat betreft prestaties en precisie, een grote dataset beschouwen en de uitvoeringstijd voor elke benadering meten.

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

In dit voorbeeld wordt een dataset van een miljoen willekeurige drijvende-kommawaarden tussen 0 en 1000 gegenereerd. De uitvoeringstijd voor elke truncatiemethode wordt gemeten met behulp van de tijdmodule. De benadering van de decimale module converteert elk getal naar een decimale instantie voordat het wordt afgekapt om nauwkeurige resultaten te garanderen.

Door de code uit te voeren, kunt u de uitvoeringstijden voor elke methode observeren en een prestatievergelijking maken.

De juiste afkapmethode kiezen

Als het gaat om het afkappen van drijvende-kommawaarden in Python, hangt het kiezen van de juiste methode af van de specifieke vereisten van de applicatie of use case.

Houd rekening met de volgende factoren bij het bepalen van de te gebruiken methode:

• Precisie: als precisie van het allergrootste belang is en u nauwkeurige controle over decimalen nodig heeft, biedt de decimale module het hoogste niveau van nauwkeurigheid.

• Prestaties: Voor eenvoudige afkapping zonder dat hoge precisie nodig is, bieden de functies int() en math.trunc() efficiënte oplossingen.

• Afrondingsgedrag: afhankelijk van het gewenste afrondingsgedrag kunt u met de decimale module verschillende afrondingsmodi specificeren, zoals ROUND_DOWN , ROUND_UP , ROUND_HALF_UP en meer.

• Compatibiliteit: als u compatibiliteit wilt garanderen met oudere code of systemen die de decimale module niet ondersteunen, kunnen de functie int() of de functie math.trunc haalbare opties zijn.

Laatste gedachten

Het begrijpen van de basisprincipes van het afkappen van float-waarden in Python is essentieel voor nauwkeurige gegevensmanipulatie en -analyse. Python biedt verschillende methoden en functies om getallen met drijvende komma af te kappen of af te ronden op basis van specifieke vereisten.

Door de ingebouwde functies zoals math.trunc() , math.floor() en math.ceil() te gebruiken , kunnen we afkapbewerkingen effectief uitvoeren. Deze functies bieden flexibiliteit bij het omgaan met positieve en negatieve float-waarden, waardoor we het gewenste resultaat kunnen controleren.

Bovendien biedt de decimale module betere controle over afronding en precisie, waardoor hij geschikt is voor financiële berekeningen of situaties waarin nauwkeurigheid voorop staat.

Zoals met elk programmeerconcept, zijn oefenen en experimenteren de sleutel tot het beheersen van de kunst van het afkappen van float-waarden. Ga je gang en pas deze technieken toe in real-world scenario's en verken aanvullende bronnen, zoals Python-documentatie en communityforums, om je begrip en vaardigheid te vergroten!