Šajā rakstā mēs apspriedīsim, kā Python noapaļot skaitļus, izmantojot piemērotas metodes un piemērus Kā noapaļot uz augšu Python .
Piemērs:
Input: 3.5 Output: 4 Explanation: Nearest whole number. Input: 3.74 Output: 3.7 Explanation: Rounded to one decimal place.>
Noapaļo skaitļus programmā Python
Skaitļa noapaļošana nozīmē skaitļa vienkāršošanu, saglabājot tā vērtību neskartu, bet tuvāk nākamajam skaitlim. Ir dažādas metodes, kā noapaļot skaitļus Python, šeit mēs apspriežam dažas parasti izmantotās metodes Kā noapaļot Python , Tālāk ir norādīti šādi punkti, kas tiks apskatīti šajā rakstā, izmantojot Python:
- Izmantojot iebūvēto round() funkciju
- Izmantojot Apcirpšana koncepcija
- Izmantojot Math.ceil() un Math.floor() funkcijas
- Izmantojot math.ceil
- Izmantojot matemātika.stāvs
- Izmantojot
numpy>Modulis - Izmantojot Noapaļošana Neobjektivitātes jēdziens
- Noapaļošana uz pusi no nulles programmā Python
Apaļie skaitļi Python u dziedāt Iebūvēts raunds() Funkcija
Python ir iebūvēts round() funkcija kas noapaļo skaitli līdz norādītajam ciparu skaitam. Funkcija round() pieņem divus ciparu argumentus, n un n ciparus, un pēc tam atgriež skaitli n pēc tā noapaļošanas līdz n cipariem. Ja noapaļošanai nav paredzēts ciparu skaits, funkcija noapaļo doto skaitli n līdz tuvākajam veselam skaitlim.
jtextfield
Piemērs : Šajā piemērā tālāk esošajā kodā ir parādīta funkcija 'round()' veseliem skaitļiem un peldošā komata skaitļiem. Tas arī ilustrē noapaļošanu līdz divām zīmēm aiz komata, parādot gadījumus, kad nākamais cipars ir 5, lielāks par 5 un mazāks par 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>> round>(>4.476>,>2>))> > # when the (ndigit+1)th digit is <5> print>(>round>(>4.473>,>2>))> |
>
>
Izvade:
11 23 4.46 4.48 4.47>
Apaļie skaitļi Python u dziedāt Apcirpšana koncepcija
Šajā funkcijā katrs cipars pēc noteiktās pozīcijas tiek aizstāts ar 0. python saīsināt () funkciju var izmantot ar pozitīviem, kā arī negatīviem skaitļiem. Saīsināšanas funkciju var īstenot šādi:
- Skaitļa reizināšana ar 10^p (10 palielināts līdz pthjauda), lai pārvietotu decimālzīmi p vietām pa labi.
- Jaunā skaitļa veselā skaitļa daļa, izmantojot int().
- Pārvietojot decimāldaļu p, atgriežas pa kreisi, dalot ar 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>))> |
>
>
Izvade:
16.0 -3.8 3.81 340.0 -2000.0>
Apaļie skaitļi Python u dziedāt Math.ceil() un Math.floor() funkcijas
Matemātika . ceil () : Šī funkcija atgriež tuvāko veselo skaitli, kas ir lielāks vai vienāds ar doto skaitli.
Math.floor() : Šī funkcija atgriež tuvāko veselo skaitli, kas ir mazāks vai vienāds ar doto skaitli.
Piemērs :Šajā piemērā tālāk norādītais kods izmanto matemātikas bibliotēku, lai aprēķinātu maksimālās vērtības pozitīvajām un negatīvajām decimāldaļām ar 'math.ceil' un zemākās vērtības ar 'math.floor'. Attiecīgajiem gadījumiem izvadi ir 5, 0, 2 un -1.
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>))> |
>
>
Izvade:
5 0 2 -1>
Apaļie skaitļi Python u dziedāt math.ceil
Skaitļa noapaļošana uz augšu ietver decimāldaļas nobīdi pa labi, noapaļošanu uz augšu un pēc tam pārvietošanu atpakaļ pa kreisi, lai nodrošinātu precizitāti, izmantojot ` math.ceil() ` un reizināšanas/dalīšanas operācijas.
Piemērs :Šajā piemērā tālāk norādītais kods definē funkciju 'round_up', izmantojot bibliotēku 'matemātika', kas noapaļo skaitli līdz noteiktai zīmei aiz komata. Tas izmanto reizināšanu, noapaļošanu ar 'math.ceil()' un dalīšanu precizitātes labad. Pozitīvās un negatīvās vērtības tiek pārbaudītas noapaļošanai.
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>))> |
>
>
Izvade:
3.0 2.3 2.55 30.0 2400.0>
Mēs varam sekot tālāk redzamajai diagrammai, lai saprastu noapaļošanu uz augšu un uz leju. Noapaļo uz augšu pa labi un uz leju pa kreisi.
Noapaļojot uz augšu, vienmēr noapaļo ciparu pa labi skaitļu rindā un noapaļojot uz leju vienmēr noapaļo ciparu pa kreisi skaitļu rindā.
Apaļie skaitļi Python u dziedāt matemātika.stāvs
Noapaļošanā uz leju skaitlis tiek noapaļots uz leju līdz noteiktam ciparu skaitam. Noapaļošanas uz leju funkciju var īstenot šādi:
- Pirmkārt, decimālpunkts n tiek pārvietots uz pareizo vietu skaitu pa labi, reizinot n ar 10 ** decimālzīmēm.
- Jaunā vērtība tiek noapaļota līdz tuvākajam veselam skaitlim, izmantojot math.floor() .
- Visbeidzot, decimālzīme tiek pārvietota atpakaļ pa kreisi, dalot ar 10 ** decimālzīmēm.
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>))> |
>
>
Izvade:
2.0 2.4 -1.0>
Apaļie skaitļi Python u dziedāt Numpy Module
NumPy modulis Python nodrošina numpy.round()>funkciju uz noapaļotiem skaitļiem. Šī funkcija noapaļo katru masīva elementu līdz tuvākajam veselam skaitlim vai līdz noteiktajam decimāldaļu skaitam.
Piemērs : Šajā piemērā tālāk norādītajā kodā tiek izmantots modulis NumPy, lai izveidotu masīvu “arr”, un noapaļo katru elementu līdz tuvākajam veselam skaitlim (noapaļots_integers) un līdz divām zīmēm aiz komata (noapaļots_decimals). Pēc tam rezultāti tiek izdrukāti parādīšanai.
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)> |
>
>
Izvade:
Nearest integer: [1. 3. 4.] Decimal places: [1.23 2.57 3.79]>
Apaļie skaitļi Python u dziedāt Noapaļošanas novirze koncepcija.
Simetrijas jēdziens ievieš noapaļošanas novirzes jēdzienu, kas apraksta, kā noapaļošana ietekmē skaitliskos datus datu kopā.
Noapaļošanas stratēģija ir vērsta uz pozitīvu bezgalības novirzi, jo vērtība vienmēr tiek noapaļota pozitīvas bezgalības virzienā. Tāpat noapaļošanas stratēģijai ir negatīva bezgalības novirze. Saīsināšanas stratēģija ir vērsta uz negatīvu bezgalības novirzi pozitīvām vērtībām un kārta uz pozitīvu bezgalību negatīvām vērtībām. Tiek uzskatīts, ka noapaļošanas funkcijām ar šo darbību kopumā ir noapaļota novirze uz nulli.
a) Noapaļošana uz pusi koncepcija Python
Noapaļošana uz pusi noapaļo katru skaitli līdz tuvākajam skaitlim ar norādīto precizitāti un pārtrauc saites, noapaļojot uz augšu.
Noapaļošanas puse uz augšu stratēģija tiek īstenota, pārvietojot decimālzīmi pa labi par vēlamo vietu skaitu. Šajā gadījumā mums būs jānosaka, vai cipars pēc nobīdītā komata ir mazāks vai lielāks par 5.
Mēs varam pievienot 0,5 vērtībai, kas tiek nobīdīta, un pēc tam noapaļot to uz leju, izmantojot funkciju math.floor().
Funkcijas round_half_up() ieviešana:
Piemērs: Šajā piemērā tālāk norādītais kods definē “round_half_up” — pielāgotu noapaļošanas funkciju, izmantojot noapaļošanas pusi uz augšu metodi ar “math.floor()” precizitātes labad. Demonstrācijās ir iekļauti pozitīvi un negatīvi skaitļi ar dažādām zīmēm aiz komata.
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>))> |
>
>
Izvade:
1.3 -1.0 -1.23>
b) Noapaļošana uz leju koncepcija Python
Tas tiek noapaļots līdz tuvākajam skaitlim, kas ir līdzīgs noapaļošanas pusei uz augšu metodei, atšķirība ir tāda, ka tiek pārtraukta saikne, noapaļojot uz mazāko no diviem skaitļiem. Noapaļošanas uz pusi uz leju stratēģija tiek īstenota, aizstājot math.floor() funkcijā round_half_up() ar math.ceil() un pēc tam atņemot 0,5, nevis saskaitot.
Funkcijas round_half_down() ieviešana:
Šajā piemērā tālāk norādītais kods definē “round_half_down”, izmantojot matemātikas bibliotēku, lai panāktu noapaļotu pusi uz leju. Tas izmanto reizināšanu, atņemšanu un 'math.ceil()', lai noapaļotu līdz nullei. Pārbaudes gadījumi ietver pozitīvas un negatīvas decimāldaļas, noapaļojot līdz vienai zīmei aiz komata.
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>))> |
>
>
Izvade:
2.0 -3.0 2.2>
Noapaļošana uz pusi no nulles programmā Python
Noapaļošanā līdz pusei no nulles mums ir jāsāk kā parasti, pārvietojot decimālzīmi pa labi noteiktu skaitu vietu, un pēc tam jaunajā skaitļā uzreiz pamaniet ciparu(d) pa labi no decimāldaļas. Ir četri gadījumi, kas jāņem vērā:
- Ja n ir pozitīvs un d>= 5, noapaļo uz augšu
- Ja n ir pozitīvs un d = 5, noapaļo uz leju
- Ja n ir negatīvs un d>= 5, noapaļo uz leju
- Ja n ir negatīvs un d <5, noapaļo uz augšu
Pēc noapaļošanas saskaņā ar iepriekš minētajiem noteikumiem, mēs varam pārvietot decimāldaļu atpakaļ pa kreisi.
- Noapaļojot pusi līdz pat: Ir veids, kā mazināt noapaļošanas novirzi, kamēr mēs noapaļojam vērtības datu kopā. Mēs varam vienkārši noapaļot saites līdz tuvākajam pāra skaitlim ar vēlamo precizitāti. Noapaļošanas puse līdz pat vienmērīgajai stratēģija ir stratēģija, ko izmanto Python iebūvētā kārta (). The decimālā klase nodrošina atbalstu ātrai pareizi noapaļotai decimāldaļskaitļa peldošā komata aritmētikai. Tas piedāvā vairākas priekšrocības salīdzinājumā ar peldošo datu tipu. Noklusējuma noapaļošanas stratēģija decimālajā modulī ir ROUND_HALF_EVEN.
Piemērs: Šajā piemērā tālāk norādītajā kodā tiek izmantota funkcija Decimal no bibliotēkas decimāldaļas, lai precīzi attēlotu decimālskaitļus. Tas kontrastē, veidojot 'Decimal' objektu no virknes un tieši no peldošā komata skaitļa. Funkcija 'quantize()' pēc tam tiek izmantota noapaļošanai ar noteiktām decimālzīmēm, demonstrējot decimāldaļaritmētikas precizitāti.
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'>)))> |
>
>
Izvade:
0.1 0.1000000000000000055511151231257827021181583404541015625 1.6 1.68>