In dit artikel bespreken we hoe je getallen in Python kunt afronden met geschikte methoden en voorbeelden van Hoe naar binnen af te ronden Python .
Voorbeeld:
Input: 3.5 Output: 4 Explanation: Nearest whole number. Input: 3.74 Output: 3.7 Explanation: Rounded to one decimal place.>
Rond getallen af in Python
Het afronden van een getal betekent dat je het getal eenvoudiger maakt door de waarde ervan intact te houden, maar dichter bij het volgende getal. Er zijn verschillende methoden om getallen in Python af te ronden. Hier bespreken we enkele methoden die algemeen worden gebruikt Hoe rond je af in Python Hieronder staan de volgende punten die in dit artikel worden behandeld met behulp van Python:
- Met behulp van de ingebouwde round()-functie
- Gebruik makend van Afknotting concept
- Gebruik makend van Math.ceil() En Math.floor() functies
- Gebruik makend van wiskunde.plafond
- Gebruik makend van wiskunde.vloer
- De ... gebruiken
numpy>Module - De ... gebruiken Afronding Vooroordeel concept
- Afronding halverwege nul in Python
Ronde getallen in Python u zingen Ingebouwd ronde() Functie
In Python is er een ingebouwd round() functie waarmee een getal wordt afgerond op het opgegeven aantal cijfers. De functie round() accepteert twee numerieke argumenten, n en n cijfers, en retourneert vervolgens het getal n nadat dit is afgerond op n cijfers. Als het aantal cijfers niet is opgegeven om af te ronden, rondt de functie het opgegeven getal n af op het dichtstbijzijnde gehele getal.
Java-visualizer
Voorbeeld : In dit voorbeeld toont de onderstaande code de functie `round()` voor gehele getallen en getallen met drijvende komma. Het illustreert ook het afronden op twee decimalen, waarbij gevallen worden gedemonstreerd waarin het volgende cijfer 5, groter dan 5 en kleiner dan 5 is.
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>))> |
>
>
Uitgang:
11 23 4.46 4.48 4.47>
Ronde getallen in Python u zingen Afknotting concept
In deze functie wordt elk cijfer na een bepaalde positie vervangen door 0. python afkappen() functie kan worden gebruikt met zowel positieve als negatieve getallen. De truncatiefunctie kan op de volgende manier worden geïmplementeerd:
- Door het getal te vermenigvuldigen met 10^p (10 verhoogd tot de pemacht) om de komma p plaatsen naar rechts te verschuiven.
- Het gehele deel van dat nieuwe getal nemen met int().
- Door de decimaalpositie p te verschuiven, wordt deze terug naar links geplaatst door te delen door 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>))> |
>
>
Uitgang:
16.0 -3.8 3.81 340.0 -2000.0>
Ronde getallen in Python u zingen Math.ceil() En Math.floor() functies
Wiskunde . plafond() : Deze functie retourneert het dichtstbijzijnde gehele getal dat groter is dan of gelijk is aan een bepaald getal.
Math.floor() : Deze functie retourneert het dichtstbijzijnde gehele getal kleiner dan of gelijk aan een bepaald getal.
Voorbeeld :In dit voorbeeld gebruikt de onderstaande code de bibliotheek `math` om plafondwaarden te berekenen voor positieve en negatieve decimalen met `math.ceil` en minimumwaarden met `math.floor`. Uitgangen zijn 5, 0, 2 en -1 voor de respectievelijke gevallen.
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>))> |
>
>
Uitgang:
5 0 2 -1>
Ronde getallen in Python u zing math.ceil
Om een getal naar boven af te ronden, wordt de komma naar rechts verschoven, naar boven afgerond en vervolgens weer naar links verschoven voor precisie met ` wiskunde.ceil() ` en bewerkingen voor vermenigvuldigen/delen.
Voorbeeld :In dit voorbeeld definieert de onderstaande code een `round_up`-functie met behulp van de `math`-bibliotheek, die een getal afrondt op een opgegeven decimaal. Het maakt gebruik van vermenigvuldiging, afronding met `math.ceil()` en deling voor precisie. Positieve en negatieve waarden worden getest op afronding.
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>))> |
>
>
Uitgang:
3.0 2.3 2.55 30.0 2400.0>
We kunnen het onderstaande diagram volgen om het afronden naar boven en naar beneden te begrijpen. Rond naar boven af naar rechts en naar beneden naar links.
Door naar boven af te ronden wordt een getal altijd naar rechts op de getallenlijn afgerond, en door naar beneden af te ronden wordt een getal altijd naar links op de getallenlijn afgerond.
Ronde getallen in Python u zingen wiskunde.vloer
Bij Naar beneden afronden wordt een getal naar beneden afgerond op een bepaald aantal cijfers. De afrondingsfunctie kan op de volgende manier worden geïmplementeerd:
- Eerst wordt de komma in n naar het juiste aantal plaatsen naar rechts verschoven door n te vermenigvuldigen met 10 ** decimalen.
- De nieuwe waarde wordt naar boven afgerond op het dichtstbijzijnde gehele getal met behulp van wiskunde.vloer() .
- Ten slotte wordt de komma weer naar links verschoven door te delen door 10 ** decimalen.
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>))> |
>
>
Uitgang:
2.0 2.4 -1.0>
Ronde getallen in Python u zing Numpy Module
De NumPy-module in Python biedt de numpy.round()>functie om getallen af te ronden. Deze functie rondt elk element van een array af op het dichtstbijzijnde gehele getal of op het opgegeven aantal decimalen.
Voorbeeld : In dit voorbeeld gebruikt de onderstaande code de NumPy-module om een array `arr` te maken en rondt elk element af op het dichtstbijzijnde gehele getal (`rounded_integers`) en op twee decimalen (`rounded_decimals`). De resultaten worden vervolgens afgedrukt voor weergave.
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)> |
>
>
Uitgang:
Nearest integer: [1. 3. 4.] Decimal places: [1.23 2.57 3.79]>
Ronde getallen in Python u zingen Afrondingsvooroordeel concept.
Het concept van symmetrie introduceert het begrip afrondingsbias, dat beschrijft hoe afronding numerieke gegevens in een dataset beïnvloedt.
De afrondingsstrategie heeft een afronding richting positieve oneindigheid, omdat de waarde altijd naar boven wordt afgerond in de richting van positieve oneindigheid. Op dezelfde manier heeft de strategie voor afronding naar beneden een ronde richting een negatieve oneindigheidsbias. De afknottingsstrategie heeft een ronde richting negatieve oneindigheid voor positieve waarden en een ronde richting positieve oneindigheid voor negatieve waarden. Er wordt gezegd dat afrondingsfuncties met dit gedrag in het algemeen een afronding naar nul bias hebben.
a) Half naar boven afronden concept in Python
Bij het half naar boven afronden wordt elk getal met de opgegeven precisie afgerond naar het dichtstbijzijnde getal en worden de verbanden verbroken door naar boven af te ronden.
De strategie voor het half naar boven afronden wordt geïmplementeerd door de komma met het gewenste aantal plaatsen naar rechts te verschuiven. In dit geval zullen we moeten bepalen of het cijfer na de verschoven decimale punt kleiner of groter dan gelijk is aan 5.
We kunnen 0,5 optellen bij de verschoven waarde en deze vervolgens naar beneden afronden met de functie math.floor().
Implementatie van de round_half_up() functie:
Voorbeeld: In dit voorbeeld definieert de onderstaande code `round_half_up`, een aangepaste afrondingsfunctie die de round half up-methode gebruikt met `math.floor()` voor precisie. Demonstraties omvatten positieve en negatieve getallen met verschillende decimalen.
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>))> |
>
>
Uitgang:
1.3 -1.0 -1.23>
b) Half naar beneden afronden concept in Python
Dit rondt af naar het dichtstbijzijnde getal, vergelijkbaar met de half-omhoog-afrondingsmethode. Het verschil is dat de verbinding wordt verbroken door af te ronden naar het kleinste van de twee getallen. De strategie voor het half naar beneden afronden wordt geïmplementeerd door math.floor() in de functie round_half_up() te vervangen door math.ceil() en vervolgens door 0,5 af te trekken in plaats van op te tellen.
Implementatie van de round_half_down() functie:
In dit voorbeeld definieert de onderstaande code `round_half_down` met behulp van de `math` bibliotheek om round-half-down gedrag te bereiken. Het maakt gebruik van vermenigvuldigen, aftrekken en `math.ceil()` voor het afronden naar nul. Testgevallen omvatten positieve en negatieve decimalen, afgerond op één decimaal.
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>))> |
>
>
Uitgang:
2.0 -3.0 2.2>
Afronding halverwege nul in Python
Bij het afronden van de helft weg van nul moeten we zoals gewoonlijk beginnen door de komma een bepaald aantal plaatsen naar rechts te verschuiven en dan het cijfer (d) onmiddellijk rechts van de decimale plaats in het nieuwe getal op te merken. Er zijn vier gevallen waarmee rekening moet worden gehouden:
- Als n positief is en d>= 5, rond dan naar boven af
- Als n positief is en d = 5, rond dan naar beneden af
- Als n negatief is en d>= 5, rond dan naar beneden af
- Als n negatief is en d <5, rond dan naar boven af
Na afronding volgens de hierboven genoemde regels, kunnen we de decimaal terug naar links verschuiven.
- Half tot even afronden: Er is een manier om de afrondingsbias te verminderen terwijl we waarden in een gegevensset afronden. We kunnen eenvoudig de stropdassen met de gewenste nauwkeurigheid afronden naar het dichtstbijzijnde even getal. De strategie voor het afronden van de helft tot even is de strategie die wordt gebruikt door de ingebouwde round() van Python. De decimale klasse biedt ondersteuning voor snelle, correct afgeronde decimale berekeningen met drijvende komma. Dit biedt verschillende voordelen ten opzichte van het float-datatype. De standaard afrondingsstrategie in de decimale module is ROUND_HALF_EVEN.
Voorbeeld: In dit voorbeeld gebruikt de onderstaande code de functie 'Decimaal' uit de bibliotheek 'decimaal' om decimale getallen nauwkeurig weer te geven. Het staat in contrast met het maken van een 'Decimaal'-object op basis van een string en rechtstreeks op basis van een getal met drijvende komma. De functie `quantize()` wordt vervolgens gebruikt voor het afronden met gespecificeerde decimalen, wat de precisie in decimale rekenkunde aantoont.
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'>)))> |
>
>
Uitgang:
0.1 0.1000000000000000055511151231257827021181583404541015625 1.6 1.68>