Pythoni round () funktsioon koos NÄIDETEGA

Lang L: none (table-of-contents):

Anonim

Ümmargune ()

Round () on sisseehitatud funktsioon, mis on saadaval pythoniga. See annab teile ujukarvu, mis ümardatakse sisendina antud kümnendkohtadeni.

Kui ümardatavaid kümnendkohti pole täpsustatud, loetakse see väärtuseks 0 ja see ümardatakse lähima täisarvuni.

Selles Pythoni õpetuses saate teada:

  • Ümmargune ()
  • Süntaks:
  • Kui suurt mõju ümardamine võib avaldada? (Ümardamine vs kärpimine)
  • Näide: ujukarvude ümardamine
  • Näide: täisarvude ümardamine
  • Näide: negatiivsete arvude ümardamine
  • Näide: ümmargused tühjad massiivid
  • Näide: kümnendmoodul

Süntaks:

round(float_num, num_of_decimals)

Parameetrid

  • float_num: ümardatav ujuki number.
  • kümnendkohtade arv: (valikuline) ümardamisel arvestatavate kümnendkohtade arv. See on valikuline ja kui seda pole määratud, on see vaikimisi 0 ja ümardamine toimub lähima täisarvuni.

Kirjeldus

Round () meetodil on kaks argumenti

  • ümardatav arv ja
  • kümnendkohad, mida ta peaks ümardamise ajal arvestama.

Teine argument on valikuline ja vaikimisi väärtuseks 0, kui seda pole määratud, ja sellisel juhul ümardatakse see lähima täisarvuni ning tagastuse tüüp on ka täisarv.

Kui kohal on kümnendkohad, so teine ​​argument, ümardatakse see määratud kohtade arvuni. Tagasitüübiks on ujuk.

Kui antud kümnendkoha järel olev arv

  • > = 5 kui + 1 lisatakse lõplikule väärtusele
  • <5 kui lõplik väärtus tagastatakse, kuna see on kuni nimetatud kümnendkohani.

Tagastusväärtus

See tagastab täisarvu, kui num_of_decimals pole antud, ja float, kui number_of_decimals on antud. Pange tähele, et väärtus ümardatakse väärtuseni +1, kui kümnendkohajärgne väärtus on> = 5, vastasel juhul tagastab see väärtuse, kui see on kuni nimetatud kümnendkohani.

Kui suurt mõju ümardamine võib avaldada? (Ümardamine vs kärpimine)

Parim näide ümardamise mõju näitamiseks on börsiturg. Varem, st 1982. aastal, Vancouveri börs (VSE): kasutas aktsiate väärtuste lühendamiseks kolme kümnendkohani igal kaubavahetusel.

Seda tehti iga päev peaaegu 3000 korda. Kogunenud kärbete tõttu kaotatakse umbes 25 punkti kuus.

Allpool on toodud näide väärtuste kärpimisest ja ümardamisest.

Vaatleme allpool genereeritud ujukoma numbreid aktsia väärtusena. Praegu genereerin seda mitmetele

1 000 000 sekundit vahemikus 0,01–0,05.

Näited:

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]

Ümardamise mõju näitamiseks olen kirjutanud väikese kooditüki, kus peate kõigepealt kasutama numbreid kuni kolme kümnendkohani, st kärpima numbrit pärast kolme kohta pärast koma.

Mul on algne koguväärtus, kogusumma pärineb kärbitud väärtustest ning erinevus algse ja kärbitud väärtuse vahel.

Sama numbrikomplekti puhul olen kasutanud ümara () meetodit kuni kolme kümnendkohani ja arvutanud summa ning algväärtuse ja ümardatud väärtuse erinevuse.

Siin on näide ja väljund

Näide 1

import randomdef truncate(num):return int(num * 1000) / 1000arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]sum_num = 0sum_truncate = 0for i in arr:sum_num = sum_num + isum_truncate = truncate(sum_truncate + i)print("Testing by using truncating upto 3 decimal places")print("The original sum is = ", sum_num)print("The total using truncate = ", sum_truncate)print("The difference from original - truncate = ", sum_num - sum_truncate)print("\n\n")print("Testing by using round() upto 3 decimal places")sum_num1 = 0sum_truncate1 = 0for i in arr:sum_num1 = sum_num1 + isum_truncate1 = round(sum_truncate1 + i, 3)print("The original sum is =", sum_num1)print("The total using round = ", sum_truncate1)print("The difference from original - round =", sum_num1 - sum_truncate1)

Väljund:

Testing by using truncating upto 3 decimal placesThe original sum is = 29985.958619386867The total using truncate = 29486.057The difference from original - truncate = 499.9016193868665Testing by using round() up to 3 decimal placesThe original sum is = 29985.958619386867The total using round = 29985.912The difference from original - round = 0.04661938686695066

Algse ja kärpimise vahe on 499.9016193868665 ja ümmargune on 0.04661938686695066

Erinevus näib olevat väga suur ja näide näitab, kuidas ümardamise () meetod aitab täpsuse lähedal arvutamisel.

Näide: ujukarvude ümardamine

Selles programmis näeme, kuidas ümardatavad arvud ümardavad sõnu

# testing round()float_num1 = 10.60 # here the value will be rounded to 11 as after the decimal point the number is 6 that is >5float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5print("The rounded value without num_of_decimals is :", round(float_num1))print("The rounded value without num_of_decimals is :", round(float_num2))print("The rounded value with num_of_decimals as 2 is :", round(float_num3, 2))print("The rounded value with num_of_decimals as 2 is :", round(float_num4, 2))

Väljund:

The rounded value without num_of_decimals is : 11The rounded value without num_of_decimals is : 10The rounded value with num_of_decimals as 2 is : 10.35The rounded value with num_of_decimals as 2 is : 10.34

Näide: täisarvude ümardamine

Kui kasutate täisarvu väärtust round (), tagastab see teile numbri lihtsalt ilma muudatusteta.

# testing round() on a integernum = 15print("The output is", round(num))

Väljund:

The output is 15

Näide: negatiivsete arvude ümardamine

Vaatame vähe näiteid selle kohta, kuidas ümardamine toimib negatiivsete arvude korral

# testing round()num = -2.8num1 = -1.5print("The value after rounding is", round(num))print("The value after rounding is", round(num1))

Väljund:

C:\pythontest>python testround.pyThe value after rounding is -3The value after rounding is -2

Näide: ümmargused tühjad massiivid

Kuidas ümardada arvukalt massiive Pythonis?

Selle lahendamiseks saame kasutada numpy moodulit ja kasutada meetodit numpy.round () või numpy.around (), nagu on näidatud allpool toodud näites.

Kasutades numpy.round ()

# testing round()import numpy as nparr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]arr1 = np.round(arr, 2)print(arr1)

Väljund:

C:\pythontest>python testround.py[-0.34 1.46 4.23 -0.34 7.63 5.12]

Saame kasutada ka numpy.around (), mis annab teile sama tulemuse, nagu on näidatud allpool toodud näites.

Näide: kümnendmoodul

Lisaks voorule () on pythonil kümnendmoodul, mis aitab kümnendarvude täpsemini käsitseda.

Kümnendmoodulil on ümardamistüübid, nagu allpool näidatud:

  • SUUNAV: ümardub lõpmatuse suunas,
  • ROUND_DOWN: ümardab väärtuse nulli suunas,
  • ROUND_FLOOR: see ümardub lõpmatuse suunas,
  • ROUND_HALF_DOWN: see ümardub lähima väärtuseni, mis läheb nulli suunas,
  • ROUND_HALF_EVEN: see ümardatakse lähima väärtuseni lähima paarisarvuni,
  • ROUND_HALF_UP: see ümardatakse lähima väärtuseni, mis läheb nullist eemale
  • ROUND_UP: see ümardub, kus väärtus läheb nullist välja.

Kümnendkohas aitab quantize () meetod ümardada kindla arvu kümnendkohtadeni ja saate määrata kasutatava ümardamise, nagu on näidatud allpool toodud näites.

Näide:

Ümarate () ja kümnendmeetodite kasutamine

import decimalround_num = 15.456final_val = round(round_num, 2)#Using decimal modulefinal_val1 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_CEILING)final_val2 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_DOWN)final_val3 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_FLOOR)final_val4 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_DOWN)final_val5 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_EVEN)final_val6 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)final_val7 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_UP)print("Using round()", final_val)print("Using Decimal - ROUND_CEILING ",final_val1)print("Using Decimal - ROUND_DOWN ",final_val2)print("Using Decimal - ROUND_FLOOR ",final_val3)print("Using Decimal - ROUND_HALF_DOWN ",final_val4)print("Using Decimal - ROUND_HALF_EVEN ",final_val5)print("Using Decimal - ROUND_HALF_UP ",final_val6)print("Using Decimal - ROUND_UP ",final_val7)

Väljund:

Using round() 15.46Using Decimal - ROUND_CEILING 15.46Using Decimal - ROUND_DOWN 15.45Using Decimal - ROUND_FLOOR 15.45Using Decimal - ROUND_HALF_DOWN 15.46Using Decimal - ROUND_HALF_EVEN 15.46Using Decimal - ROUND_HALF_UP 15.46Using Decimal - ROUND_UP 15.46

Kokkuvõte:

  • Round (float_num, Num_of_decimals) on sisseehitatud funktsioon, mis on saadaval pythoniga. See tagastab ujuki numbri, mis ümardatakse sisendina antud kümnendkohtadeni.
  • float_num: ümardatav ujuki number.
  • Kümnendkohtade arv: see on ümardamisel arvestatav kümnendkohtade arv.
  • See tagastab täisarvu, kui num_of_decimals pole antud, ja float, kui number_of_decimals on antud.