I denne artikel vil vi diskutere, hvordan man afrunder tal i Python med passende metoder og eksempler på Sådan rundes ind Python .
Eksempel:
Input: 3.5 Output: 4 Explanation: Nearest whole number. Input: 3.74 Output: 3.7 Explanation: Rounded to one decimal place.>
Afrund tal opad i Python
At afrunde et tal betyder at gøre tallet enklere ved at holde dets værdi intakt, men tættere på det næste tal. Der er forskellige metoder til at afrunde tal i Python her, vi diskuterer nogle generelt brugt til Sådan rundes op i Python , Nedenfor er følgende punkter, der vil blive dækket i denne artikel ved hjælp af Python:
- Brug af den indbyggede round() funktion
- Ved brug af Trunkering koncept
- Ved brug af Math.ceil() og Math.floor() funktioner
- Ved brug af math.loft
- Ved brug af matematik.gulv
- Bruger
numpy>modul - Bruger Afrunding Bias koncept
- Runder halvt væk fra nul i Python
Runde tal i Python u synge Indbygget rund() Fungere
I Python er der indbygget round() funktion der runder et tal af til det givne antal cifre. Funktionen round() accepterer to numeriske argumenter, n og n cifre, og returnerer derefter tallet n efter at have rundet det til n cifre. Hvis antallet af cifre ikke er angivet til afrunding, runder funktionen det givne tal n af til nærmeste heltal.
hvad er rom
Eksempel: I dette eksempel viser nedenstående kode funktionen `round()` for heltal og flydende kommatal. Det illustrerer også afrunding til to decimaler og viser tilfælde, hvor det næste ciffer er 5, større end 5 og mindre end 5.
python3
# For integers> print>(>round>(>11>))> # For floating point> print>(>round>(>22.7>))> # if the second parameter is present> # when the (ndigit+1)th digit is =5> print>(>round>(>4.465>,>2>))> > # when the (ndigit+1)th digit is>=5> print>(>round>(>4.476>,>2>))> > # when the (ndigit+1)th digit is <5> print>(>round>(>4.473>,>2>))> |
>
>
Produktion:
11 23 4.46 4.48 4.47>
Runde tal i Python u synge Trunkering koncept
I denne funktion erstattes hvert ciffer efter en given position med 0. python afkorte() fungere kan bruges med positive såvel som negative tal. Trunkeringsfunktionen kan implementeres på følgende måde:
- Multiplicer tallet med 10^p (10 hævet til pthpotens) for at flytte decimaltegnet p steder til højre.
- Tager heltalsdelen af det nye tal ved hjælp af int().
- Ved at flytte decimalen p placeres tilbage til venstre ved at dividere med 10^p.
python3
# defining truncate function> # second argument defaults to 0> # so that if no argument is passed> # it returns the integer part of number> def> truncate(n, decimals>=> 0>):> >multiplier>=> 10> *>*> decimals> >return> int>(n>*> multiplier)>/> multiplier> print>(truncate(>16.5>))> print>(truncate(>->3.853>,>1>))> print>(truncate(>3.815>,>2>))> # we can truncate digits towards the left of the decimal point> # by passing a negative number.> print>(truncate(>346.8>,>->1>))> print>(truncate(>->2947.48>,>->3>))> |
>
>
Produktion:
16.0 -3.8 3.81 340.0 -2000.0>
Runde tal i Python u synge Math.ceil() og Math.floor() funktioner
Matematik . loft() : Denne funktion returnerer det nærmeste heltal, der er større end eller lig med et givet tal.
Math.floor() : Denne funktion returnerer det nærmeste heltal mindre end eller lig med et givet tal.
Eksempel :I dette eksempel bruger nedenstående kode biblioteket `math` til at beregne loftværdier for positive og negative decimaler med `math.ceil` og bundværdier med `math.floor`. Udgangene er 5, 0, 2 og -1 for de respektive tilfælde.
python3
# import math library> import> math> # ceil value for positive> # decimal number> print>(math.ceil(>4.2>))> # ceil value for negative> # decimal number> print>(math.ceil(>->0.5>))> # floor value for decimal> # and negative number> print>(math.floor(>2.2>))> print>(math.floor(>->0.5>))> |
>
>
Produktion:
5 0 2 -1>
Runde tal i Python u synge matematik.loft
Afrunding af et tal indebærer at flytte decimaltegnet til højre, runde op og derefter flytte det tilbage til venstre for præcision ved at bruge ` math.ceil() ` og multiplikation/division operationer.
Eksempel :I dette eksempel definerer nedenstående kode en 'round_up'-funktion ved hjælp af 'matematik'-biblioteket, som afrunder et tal til en specificeret decimal. Den bruger multiplikation, afrunding med `math.ceil()` og division for præcision. Positive og negative værdier testes for afrunding.
python3
# import math library> import> math> # define a function for> # round_up> def> round_up(n, decimals>=> 0>):> >multiplier>=> 10> *>*> decimals> >return> math.ceil(n>*> multiplier)>/> multiplier> # passing positive values> print>(round_up(>2.1>))> print>(round_up(>2.23>,>1>))> print>(round_up(>2.543>,>2>))> # passing negative values> print>(round_up(>22.45>,>->1>))> print>(round_up(>2352>,>->2>))> |
>
>
Produktion:
3.0 2.3 2.55 30.0 2400.0>
Vi kan følge diagrammet nedenfor for at forstå runde op og runde ned. Rund op til højre og ned til venstre.

Afrunding opad runder altid et tal til højre på tallinjen og afrunding nedad runder altid et tal til venstre på tallinjen.
Runde tal i Python u synge matematik.gulv
I Rounding Down afrundes et tal ned til et bestemt antal cifre. Afrundingsfunktionen kan implementeres på følgende måde:
- Først flyttes decimaltegnet i n til det korrekte antal pladser til højre ved at gange n med 10 ** decimaler.
- Den nye værdi rundes op til nærmeste heltal vha math.floor() .
- Til sidst flyttes decimaltegnet tilbage til venstre ved at dividere med 10 ** decimaler.
python3
import> math> # defining a function for> # round down.> def> round_down(n, decimals>=>0>):> >multiplier>=> 10> *>*> decimals> >return> math.floor(n>*> multiplier)>/> multiplier> # passing different values to function> print>(round_down(>2.5>))> print>(round_down(>2.48>,>1>))> print>(round_down(>->0.5>))> |
>
>
Produktion:
2.0 2.4 -1.0>
Runde tal i Python u syng Numpy Module
NumPy-modulet i Python giver numpy.round()>fungere at afrunde tal. Denne funktion afrunder hvert element i en matrix til det nærmeste heltal eller til det angivne antal decimaler.
Eksempel: I dette eksempel bruger nedenstående kode NumPy-modulet til at skabe et array 'arr' og afrunder hvert element til det nærmeste heltal ('rounded_integers') og til to decimaler ('rounded_decimals'). Resultaterne udskrives derefter til visning.
Python3
import> numpy as np> # Creating an array> arr>=> np.array([>1.234>,>2.567>,>3.789>])> # Rounding each element to the nearest integer> rounded_integers>=> np.>round>(arr)> # Rounding each element to two decimal places> rounded_decimals>=> np.>round>(arr, decimals>=>2>)> # Displaying the results> print>(>'Nearest integer:'>, rounded_integers)> print>(>'Decimal places:'>, rounded_decimals)> |
>
>
Output:
Nearest integer: [1. 3. 4.] Decimal places: [1.23 2.57 3.79]>
Runde tal i Python u synge Afrunding Bias koncept.
Begrebet symmetri introducerer begrebet afrundingsbias, som beskriver, hvordan afrunding påvirker numeriske data i et datasæt.
Afrundingsstrategien har en runde mod positiv uendelig bias, da værdien altid rundes op i retning af positiv uendelighed. På samme måde har afrundingsstrategien en runde mod negativ uendelig bias. Trunkeringsstrategien har en runde mod negativ uendelig bias på positive værdier og en runde mod positiv uendelighed for negative værdier. Afrundingsfunktioner med denne adfærd siges generelt at have en runde mod nul bias.
a) Afrunding halvt op koncept i Python
Afrundingen halvt op runder hvert tal til det nærmeste tal med den specificerede præcision og bryder båndene ved at runde op.
Strategien med at runde halvt op implementeres ved at flytte decimaltegnet til højre med det ønskede antal pladser. I dette tilfælde bliver vi nødt til at bestemme, om cifferet efter det forskudte decimalkomma er mindre end eller større end lig med 5.
Vi kan tilføje 0,5 til den værdi, der flyttes, og derefter runde den ned med math.floor()-funktionen.
Implementering af round_half_up() funktion:
Eksempel: I dette eksempel definerer nedenstående kode `round_half_up`, en brugerdefineret afrundingsfunktion, der bruger metoden round half up med `math.floor()` for præcision. Demonstrationer omfatter positive og negative tal med forskellige decimaler.
python3
import> math> # defining round_half_up> def> round_half_up(n, decimals>=>0>):> >multiplier>=> 10> *>*> decimals> >return> math.floor(n>*> multiplier>+> 0.5>)>/> multiplier> # passing different values to the function> print>(round_half_up(>1.28>,>1>))> print>(round_half_up(>->1.5>))> print>(round_half_up(>->1.225>,>2>))> |
>
>
Produktion:
1.3 -1.0 -1.23>
b) Afrunding halvt ned koncept i Python
Dette afrundes til det nærmeste tal svarende til afrunding halv-op-metoden, forskellen er, at det bryder båndene ved at afrunde til det mindste af de to tal. Afrunding halvt ned-strategi implementeres ved at erstatte math.floor() i funktionen round_half_up() med math.ceil() og derefter ved at trække 0,5 fra i stedet for at addere.
Implementering af round_half_down() funktion:
I dette eksempel definerer nedenstående kode 'round_half_down' ved at bruge 'matematik'-biblioteket for at opnå round-half-down adfærd. Den bruger multiplikation, subtraktion og `math.ceil()` til at runde mod nul. Testtilfælde omfatter positive og negative decimaler, afrundet til én decimal.
python3
# import math library> import> math> # defining a function> # for round_half_down> def> round_half_down(n, decimals>=>0>):> >multiplier>=> 10> *>*> decimals> >return> math.ceil(n>*> multiplier>-> 0.5>)>/> multiplier> # passing different values to the function> print>(round_half_down(>2.5>))> print>(round_half_down(>->2.5>))> print>(round_half_down(>2.25>,>1>))> |
>
>
Produktion:
2.0 -3.0 2.2>
Afrunding halvt væk fra nul i Python
Ved at runde halvt væk fra nul skal vi starte som sædvanligt med at flytte decimaltegnet til højre et givet antal pladser og så lægge mærke til cifferet(d) umiddelbart til højre for decimalen i det nye tal. Der er fire sager at overveje:
- Hvis n er positiv og d>= 5, rundes op
- Hvis n er positiv og d = 5, rundes ned
- Hvis n er negativ og d>= 5, rundes ned
- Hvis n er negativ og d <5, rundes op
Efter afrunding i henhold til reglerne nævnt ovenfor, kan vi flytte decimalen tilbage til venstre.
- Afrunding halvleg til lige: Der er en måde at afbøde afrundingsbias, mens vi afrunder værdier i et datasæt. Vi kan blot afrunde bånd til nærmeste lige tal med den ønskede præcision. Afrunding halv til lige strategi er den strategi, der bruges af Pythons indbyggede runde(). Det decimalklasse giver understøttelse af hurtig korrekt afrundet decimal aritmetik med flydende komma. Dette giver flere fordele i forhold til float-datatypen. Standard afrundingsstrategi i decimalmodulet er ROUND_HALF_EVEN.
Eksempel: I dette eksempel bruger nedenstående kode funktionen `Decimal` fra `decimal`-biblioteket til at repræsentere decimaltal præcist. Det står i kontrast til at skabe et 'decimal'-objekt fra en streng og direkte fra et flydende kommatal. Funktionen `quantize()` bruges derefter til afrunding med specificerede decimaler, hvilket demonstrerer præcision i decimalregning.
python3
# import Decimal function from> # decimal library> from> decimal>import> Decimal> print>(Decimal(>'0.1'>))> print>(Decimal(>0.1>))> # Rounding a Decimal number is> # done with the .quantize() function> # '1.0' in .quantize() determines the> # number of decimal places to round the number> print>(Decimal(>'1.65'>).quantize(Decimal(>'1.0'>)))> print>(Decimal(>'1.675'>).quantize(Decimal(>'1.00'>)))> |
>
>
Produktion:
0.1 0.1000000000000000055511151231257827021181583404541015625 1.6 1.68>