Katkaise kellunta Pythonissa: selitetty esimerkein

Liukulukuluvun katkaiseminen on yleinen toimenpide, jonka monet ohjelmoijat kohtaavat eri sovelluksissa. Prosessi sisältää floatin desimaalipisteen poistamisen, jolloin jäljelle jää vain kokonaislukuosa. Se on arvokas tekniikka laskelmien yksinkertaistamiseen, tulosteen luettavuuden parantamiseen ja mahdollisten pyöristysvirheiden vähentämiseen.

Voit lyhentää kelluvia arvoja Pythonissa käyttämällä math.trunc()-funktiota, desimaalimoduulia tai merkkijonojen käsittelyä. Käyttämällä näitä tekniikoita Python-kehittäjät voivat räätälöidä katkaisuprosessin omien vaatimustensa mukaan joustavasti ja tarkasti.

Tässä artikkelissa tutkimme, kuinka katkaisua voidaan käyttää sisällä . Tutustumme erilaisiin käytännön esimerkkeihin ja esittelemme kattavan katsauksen siitä, kuinka tätä tekniikkaa käytetään maksimaalisen vaikutuksen saavuttamiseksi.

Aloitetaan tarkastelemalla peruskäsitteitä ja tekniikoita merkkijonojen, numeroiden ja tietorakenteiden katkaisemiseksi Pythonissa.

Sisällysluettelo

• Python Truncate -perusteet
  • 1. Katkaisun määritelmä Pythonissa
  • 2. Python Truncate -funktion käyttäminen
  • 3. Kuinka katkaista desimaalipisteet ja kellukkeet Pythonissa
• Katkaisu Pythonissa matemaattisen kirjaston ja funktioiden avulla
  • 1. math.trunc()
  • 2. math.floor() ja math.ceil()
  • 3. Kelluvan arvon muunnos käyttämällä int()
• Pythonin arvojen lyhentäminen desimaalimoduulilla
  • 1. Kvantisointimenetelmän käyttäminen
  • 2. To_integral_value -menetelmän käyttäminen
  • 3. Normalisointimenetelmän käyttäminen
• Pythonin merkkijonojen ja listojen katkaisutekniikat
  • 1. String Truncate Techniques
  • 2. Lista katkaisu
• NumPyn ja pantojen käyttäminen arvojen lyhentämiseen Pythonissa
  • 1. Katkaisu Pythonissa NumPyn avulla
  • 2. DataFramen ja Locin käyttäminen Pythonin katkaisussa
• 3 Pythonin katkaisun käytännön sovellukset
• Katkaisumenetelmien vertailu Pythonissa
• Sopivan katkaisutavan valitseminen
• Lopulliset ajatukset

Python Truncate -perusteet

Tässä osiossa käsittelemme katkaisun määritelmää, tarkastelemme Python-funktioita katkaisua varten ja opimme lyhentämään desimaalipisteitä ja kellukkeita.

1. Katkaisun määritelmä Pythonissa

Katkaisu on prosessi, jossa numeroa lyhennetään poistamalla desimaali. Se on tärkeä käsite tietojenkäsittelytieteessä ja matematiikassa, ja sitä käytetään vähentämään numeroita yksinkertaisempaan muotoon muuttamatta niiden arvoa.

2. Python Truncate -funktion käyttäminen

Pythonissa on useita tapoja lyhentää absoluuttisia arvoja. Yksi yleinen tapa lyhennyksen saavuttamiseksi on käyttää math.trunc()- funktiota, joka poistaa suoraan desimaalit binääriliukulukuarvosta.

Tässä on esimerkki:

import math

float1 = 123.356
float2 = -2434.545

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

Lähtö:

123
-2434

Tämä menetelmä antaa samanlaisia ​​tuloksia kuin int() -funktio, joka myös katkaisee annetun luvun poistamalla desimaalit.

3. Kuinka katkaista desimaalipisteet ja kellukkeet Pythonissa

Joissakin tapauksissa saatat joutua katkaisemaan kellukkeen tiettyyn määrään desimaalilukuja. Pyöreä ()- funktiota voidaan käyttää pyöristämään numeroita tällaisissa tapauksissa. Huomaa kuitenkin, että round()- funktio vain pyöristää luvun, ei katkaisee sitä.

Jos haluat katkaista tietyn desimaalin tarkkuuden, voit käyttää seuraavaa lähestymistapaa:

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)

Lähtö:

3.14

Yllä olevassa esimerkissä tronate_float()- funktio ottaa kaksi parametria - typistettävän float-luvun ja halutun desimaalipisteiden määrän.

Se käyttää kertoimella ensin liukulukujen desimaalipilkun siirtoa, muuntaa sitten tuloksen kokonaisluvuksi (katkaisen luvun tehokkaasti) ja lopuksi jakaa kokonaisluvun kertoimella palauttaakseen desimaalipilkun alkuperäiseen sijaintiinsa.

Muista, että työskentely kellukkeiden kanssa Pythonissa voi johtaa epätarkkuuteen laskelmissa liukulukuaritmeettisen luonteen vuoksi. Siksi, kun tarkkuus ja tarkkuus ovat tärkeitä, harkitse desimaalimoduulin käyttöä .

Selvä, tämä on perusasiat arvojen katkaisemisesta Pythonissa. Seuraavassa osiossa tarkastellaan, kuinka voit lyhentää arvoja matemaattisen kirjaston ja muiden Python-funktioiden avulla.

Katkaisu Pythonissa matemaattisen kirjaston ja funktioiden avulla

Python-ohjelmoinnin alueella optimointi on usein avainasemassa. Pythonin "matematiikan" kirjaston ja sen sisäänrakennettujen toimintojen käyttäminen voi parantaa suorituskykyä merkittävästi, etenkin kun käsitellään suuria tietojoukkoja tai monimutkaisia ​​laskelmia.

Tämä osio on omistettu tutkimaan, kuinka voimme hyödyntää "matematiikan" kirjastoa ja sen vankkoja toimintoja katkaisutehtävissä – pienentämällä tai rajoittamalla tehokkaasti tietokokoa – Pythonissa.

1. math.trunc()

Pythonin matemaattinen kirjasto tarjoaa useita toimintoja, jotka toimivat kelluvien arvojen kanssa, joista yksi on math.trunc() . Tämä funktio palauttaa tietyn kellukkeen typistetyn arvon, poistaen sen murto-osan ja jättää vain kokonaisluvun.

Tässä on esimerkki math.trunc() -tiedoston käytöstä :

import math

number = 3.7
truncated_number = math.trunc(number)

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

Lähtö:

3
3.7

math.trunc() pyöristää luvun nollaa kohti. Positiivisille luvuille se toimii kuten kerrosfunktio, ja negatiivisille luvuille se toimii kuten kattofunktio.

2. math.floor() ja math.ceil()

Math.trunc() -funktion lisäksi matemaattisessa kirjastossa on myös funktioita lukujen pyöristämiseen eri tavoin, kuten math.floor() - ja math.ceil()- funktiot.

Math.floor () -funktio pyöristää liukulukuarvot alaspäin lähimpään kokonaislukuun, kun taas math.ceil() pyöristää ylöspäin lähimpään kokonaislukuun.

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) 

Lähtö:

Floor of x: 3
Floor of y: 9

Tässä on esimerkki math.floor() -funktiosta

Tämä koodinpätkä havainnollistaa funktion math.ceil() käyttöä :

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) 

Lähtö:

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

3. Kelluvan arvon muunnos käyttämällä int()

Toinen tapa lyhentää kelluvaa arvoa on käyttää sisäänrakennettua int() -funktiota. Kun se välitetään floatissa, se muuntaa sen kokonaisluvuksi katkaisemalla desimaaliosan.

Tämä lähestymistapa voi olla kätevämpi yksinkertaisissa katkaisutapauksissa, koska se ei vaadi matemaattisen kirjaston tuontia.

float5 = 7.65
float6 = -3.14

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

Lähtö:

7
-3

On kuitenkin tärkeää muistaa, että int()- funktio ei ole sama kuin math.floor() tai math.ceil() , koska se vain katkaisee luvun ottamatta huomioon sen etumerkkiä.

Tässä on esimerkki yllä olevasta int()- funktiosta float-typistykselle koodieditorissa;

Yhteenvetona voidaan todeta, että Pythonin matemaattinen kirjasto tarjoaa useita toimintoja työskennelläksesi kelluvien arvojen kanssa, mukaan lukien katkaisu, pyöristys alaspäin ja pyöristys ylöspäin. Matemaattinen kirjasto on olennainen työkalu, johon voit luottaa, kun sinun on suoritettava edistyneitä matemaattisia operaatioita.

Vaikka int()- ja math.trunc()- funktiot tarjoavat yksinkertaisia ​​tapoja lyhentää liukulukuarvoja, desimaalimoduuli tarjoaa tehokkaamman ja tarkemman lähestymistavan, joten tarkastellaan sitä seuraavassa osassa.

Pythonin arvojen lyhentäminen desimaalimoduulilla

Pythonin "desimaali"-moduuli on tehokas työkalu, joka tarjoaa tarkan desimaalilukujen käsittelyn, ominaisuus, joka on erityisen kätevä, kun katkaisua tarvitaan.

Tämä osio sukeltaa tämän moduulin käytännön sovelluksiin arvojen lyhentämiseen Pythonissa. Tutkimme vaiheittaisia ​​esimerkkejä ja annamme syvällisen käsityksen tämän tehokkaan ja tarkan tietojenkäsittelytekniikan taustalla olevista käsitteistä.

1. Kvantisointimenetelmän käyttäminen

Decimal- luokan kvantisointimenetelmä on monipuolinen työkalu desimaalilukujen lyhentämiseen . Tämän menetelmän avulla kehittäjät voivat asettaa halutun tarkkuuden ja pyöristystilan, mikä varmistaa tarkan katkaisun.

Harkitse seuraavaa esimerkkiä:

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

Lähtö:

3

Tässä esimerkissä kvantisointimenetelmää sovelletaan desimaali- ilmentymän numeroon yhden desimaalin tarkkuudella ja ROUND_DOWN- pyöristystilaa, joka tehokkaasti katkaisee arvon.

2. To_integral_value -menetelmän käyttäminen

Toinen Decimal -luokan tarjoama hyödyllinen menetelmä on to_integral_value . Tämä menetelmä palauttaa lähimmän kokonaisluvun annettuun desimaaliarvoon ja katkaisee desimaalit tehokkaasti.

To_integral_value - menetelmän avulla kehittäjät voivat määrittää myös pyöristystilan.

Tässä on esimerkki:

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

Lähtö:

3

Tässä esimerkissä menetelmää to_integral_value käytetään ROUND_DOWN- pyöristystilan kanssa, mikä johtaa katkaisuun.

3. Normalisointimenetelmän käyttäminen

Desimaaliluokan normalisointimenetelmä tarjoaa tavan säätää desimaaliinstanssin eksponenttia ja asteikkoa . Käyttämällä tätä menetelmää kehittäjät voivat lyhentää desimaalipisteitä tehokkaasti.

Harkitse seuraavaa esimerkkiä:

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

Lähtö:

3.14159

Tässä esimerkissä normalisointimenetelmää sovelletaan Desimaali - ilmentymän numeroon , jolloin saadaan sama arvo ilman desimaalipaikkoja.

Seuraavaksi tarkastellaan tapoja katkaista merkkijonoja ja luetteloita Pythonissa.

Pythonin merkkijonojen ja listojen katkaisutekniikat

Tässä osiossa käsittelemme erilaisia ​​tekniikoita merkkijonojen ja luetteloiden katkaisemiseksi Python-funktioissa. Käsittelemme seuraavat alaosat: merkkijonojen katkaisutekniikat ja luettelon katkaisu .

1. String Truncate Techniques

Pythonissa on useita tapoja lyhentää, mukaan lukien str.format , viipalointi ja f-merkkijonojen käyttö .

1) Str.formatin käyttäminen : Tämän menetelmän avulla voit katkaista merkkijonon määrittämällä tarkkuusarvon. Esimerkiksi:

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

Lähtö:

aaabb

2) Viipaloinnin käyttäminen : Voit valita alkuperäisen merkkijonon alimerkkijonon käyttämällä viipalointimerkintää. Esimerkiksi:

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

Lähtö:

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 , 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

Käyttämällä lokia ja ehtoa voimme saavuttaa katkaisun myös arvojen perusteella:

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

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

Lähtö:

       A      B
0  1.234  4.567
1  5.678  8.901

Tässä esimerkissä loogista ehtoa käytettiin suodattamaan rivit pois DataFramesta. Käyttötapauksestasi riippuen voit soveltaa erilaisia ​​ehtoja ja toimintoja käyttämällä loc .

Katsotaan nyt katkaisun käytännön sovelluksia Pythonissa.

3 Pythonin katkaisun käytännön sovellukset

Pythonin katkaisun käsitteen ja sitä vastaavien tekniikoiden ymmärtäminen on vain puolet yhtälöstä. Toinen puoli sisältää tämän tiedon tehokkaan soveltamisen käytännön skenaarioissa.

Tässä osiossa siirrymme teoriasta käytäntöön, havainnollistaen kuinka katkaisua voidaan käyttää Python-koodin optimointiin reaalimaailman sovelluksissa.

Katkaisu on hyödyllinen useissa sovelluksissa, joista jotkin ovat:

1. Taloudelliset laskelmat : Kun työskentelet valuuttojen kanssa, on tavallista lyhentää desimaaliarvoja edustamaan todellista rahaa, kun otetaan huomioon vain sentit ja pienemmät yksiköt eivät ole tärkeitä.

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

Lähtö:

49.98

2. Tietojen yhdistäminen : Katkaisua voidaan käyttää myös tietojen yhdistämiseen tietyn kriteerin mukaisesti. Esimerkiksi päivittäisten lämpötilalukemien keskiarvon aggregointi kokonaislukuarvojen perusteella.

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)

Lähtö:

23.142857142857142

3. Elementtien järjestäminen : Joskus elementit on järjestettävä tietyn katkaisusäännön perusteella. Tämä voidaan saavuttaa käyttämällä Pythonin sorted() -funktion avainparametria .

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)

Lähtö:

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

Nämä reaalimaailman katkaisusovellukset osoittavat, että se on korvaamaton useilla eri aloilla, kuten data-analyysissä ja koneoppimisessa.

Silti herää tärkeä kysymys: miten katkaisutekniikat vertautuvat toisiinsa ja mitä menetelmää sinun tulisi käyttää tietyssä skenaariossa? Vastataksemme tähän, seuraavassa jaksossamme sukeltaa vertaileva analyysi eri katkaisumenetelmistä olemme keskustelleet.

Katkaisumenetelmien vertailu Pythonissa

Vertaaksemme eri katkaisumenetelmiä suorituskyvyn ja tarkkuuden suhteen, tarkastellaan suurta tietojoukkoa ja mitataan kunkin lähestymistavan suoritusaika.

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

Tässä esimerkissä luodaan miljoonan satunnaisen liukulukuarvon tietojoukko välillä 0–1000. Kunkin katkaisumenetelmän suoritusaika mitataan aikamoduulilla. Desimaalimoduulin lähestymistapa muuntaa jokaisen luvun desimaaliinstanssiksi ennen katkaisua tarkkojen tulosten varmistamiseksi.

Suorittamalla koodia voit tarkkailla kunkin menetelmän suoritusaikoja ja tehdä suorituskykyvertailua.

Sopivan katkaisutavan valitseminen

Pythonin liukulukuarvojen lyhentämisessä sopivan menetelmän valinta riippuu sovelluksen tai käyttötapauksen erityisvaatimuksista.

Ota huomioon seuraavat tekijät, kun päätät, mitä menetelmää käytetään:

• Tarkkuus: Jos tarkkuus on äärimmäisen tärkeää ja tarvitset desimaalien hienosäätöä, desimaalimoduuli tarjoaa korkeimman tarkkuuden.

• Suorituskyky: Int() -funktio ja math.trunc()- funktio tarjoavat tehokkaita ratkaisuja yksinkertaiseen katkaisuun ilman suurta tarkkuutta .

• Pyöristyskäyttäytyminen: Halutusta pyöristyskäyttäytymisestä riippuen desimaalimoduuli antaa sinun määrittää erilaisia ​​pyöristystiloja, kuten ROUND_DOWN , ROUND_UP , ROUND_HALF_UP ja paljon muuta.

• Yhteensopivuus: Jos sinun on varmistettava yhteensopivuus vanhan koodin tai järjestelmien kanssa, jotka eivät tue desimaalimoduulia, int() -funktio tai math.trunc -funktio voivat olla käyttökelpoisia vaihtoehtoja.

Lopulliset ajatukset

Pythonin float-arvojen katkaisemisen perusteiden ymmärtäminen on välttämätöntä tietojen tarkan käsittelyn ja analysoinnin kannalta. Python tarjoaa erilaisia ​​menetelmiä ja toimintoja liukulukujen katkaisemiseen tai pyöristämiseen erityisvaatimusten perusteella.

Käyttämällä sisäänrakennettuja funktioita, kuten math.trunc() , math.floor() ja math.ceil() , voimme suorittaa katkaisutoiminnot tehokkaasti. Nämä toiminnot tarjoavat joustavuutta positiivisten ja negatiivisten kelluvien arvojen käsittelyssä, jolloin voimme hallita haluttua tulosta.

Lisäksi desimaalimoduuli tarjoaa paremman pyöristyksen ja tarkkuuden hallinnan, joten se sopii talouslaskelmiin tai tilanteisiin, joissa tarkkuus on ensiarvoisen tärkeää.

Kuten missä tahansa ohjelmointikonseptissa, harjoittelu ja kokeilu ovat avainasemassa kelluvien arvojen lyhentämisen hallitsemisessa. Käytä näitä tekniikoita todellisissa skenaarioissa ja tutustu lisäresursseihin, kuten Python-dokumentaatioon ja yhteisön foorumeihin, parantaaksesi ymmärrystäsi ja pätevyyttäsi!