Python round () -funktion med EXAMPLES

Innehållsförteckning:

Anonim

Runda()

Round () är en inbyggd funktion tillgänglig med python. Det ger dig ett flytnummer som avrundas till decimalerna som anges som inmatning.

Om decimalerna som ska avrundas inte anges betraktas det som 0 och det avrundas till närmaste heltal.

I denna Python-handledning lär du dig:

  • Runda()
  • Syntax:
  • Hur stor effekt kan avrundning ha? (Avrundning mot avkortning)
  • Exempel: Avrundning av flytnummer
  • Exempel: Avrundning av heltalvärden
  • Exempel: Avrundning på negativa siffror
  • Exempel: Round Numpy Arrays
  • Exempel: decimalmodul

Syntax:

round(float_num, num_of_decimals)

Parametrar

  • float_num: flottörnumret som ska avrundas.
  • num_of_decimals: (valfritt) Antalet decimaler som ska beaktas vid avrundning. Det är valfritt, och om det inte anges är det som standard 0 och avrundningen görs till närmaste heltal.

Beskrivning

Metoden round () tar två argument

  • antalet som ska avrundas och
  • decimaler som den bör beakta vid avrundning.

Det andra argumentet är valfritt och är som standard 0 när det inte anges, och i så fall avrundas det till närmaste heltal och returtypen kommer också att vara ett heltal.

När decimalerna, dvs. det andra argumentet, är närvarande, avrundas det till antalet angivna platser. Returtypen är en flottör.

Om siffran efter decimalen anges

  • > = 5 än + 1 läggs till det slutliga värdet
  • <5 än det slutliga värdet kommer tillbaka eftersom det är upp till decimalerna som nämns.

Returvärde

Det returnerar ett heltal om num_of_decimals inte ges och ett float-värde om num_of_decimals ges. Observera att värdet kommer att avrundas till +1 om värdet efter decimalpunkten är> = 5 annars returnerar det värdet eftersom det är upp till decimalerna som nämns.

Hur stor effekt kan avrundning ha? (Avrundning mot avkortning)

Det bästa exemplet för att visa effekterna av avrundning är för börsmarknaden. Tidigare, dvs. år 1982, använde Vancouver Stock Exchange (VSE): att avkorta aktievärdena till tre decimaler vid varje handel.

Det gjordes nästan 3000 gånger varje dag. De ackumulerade avkortningarna leder till en förlust på cirka 25 poäng per månad.

Ett exempel på avkortning av värden kontra avrundning visas nedan.

Betrakta de flytande punktnumren som genereras nedan som lagervärden. Just nu genererar jag det för en rad

1 000 000 sekunder mellan 0,01 och 0,05.

Exempel:

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

För att visa effekterna av avrundning har jag skrivit en liten kodkod där du först måste använda siffrorna upp till endast 3 decimaler, dvs avkorta numret efter 3 decimaler.

Jag har det ursprungliga totala värdet, det totala antalet kommer från trunkerade värden och skillnaden mellan original och trunkerat värde.

På samma antal siffror har jag använt runda () metoden upp till 3 decimaler och beräknat summan och skillnaden mellan det ursprungliga värdet och det avrundade värdet.

Här är exemplet och utdata

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

Produktion:

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

Skillnaden mellan original och efter avkortning är 499.9016193868665, och från runda är det 0,04661938686695066

Skillnaden verkar vara väldigt stor, och exemplet visar hur man rundar () -metoden hjälper till att beräkna nära noggrannhet.

Exempel: Avrundning av flytnummer

I detta program kommer vi att se hur avrundande ord på flytande siffror

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

Produktion:

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

Exempel: Avrundning av heltalvärden

Om du råkar använda round () på ett heltal, kommer det bara att returnera numret tillbaka utan några ändringar.

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

Produktion:

The output is 15

Exempel: Avrundning på negativa siffror

Låt oss se några exempel på hur avrundning fungerar på negativa siffror

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

Produktion:

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

Exempel: Round Numpy Arrays

Hur avrundar jag domnade matriser i python?

För att lösa detta kan vi använda numpy-modulen och använda metoden numpy.round () eller numpy.around (), som visas i exemplet nedan.

Använda 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)

Produktion:

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

Vi kan också använda numpy.around (), vilket ger dig samma resultat som visas i exemplet nedan.

Exempel: decimalmodul

Förutom funktionen round () har python en decimalmodul som hjälper till att hantera decimaltal mer exakt.

Decimalmodulen levereras med avrundningstyper, som visas nedan:

  • ROUND_CEILING: den kommer att rundas mot oändligheten,
  • ROUND_DOWN: det kommer att avrunda värdet mot noll,
  • ROUND_FLOOR: den kommer att avrunda mot -Oändligheten,
  • ROUND_HALF_DOWN: det kommer att avrunda till närmaste värde som går mot noll,
  • ROUND_HALF_EVEN: det kommer att avrunda till närmaste med värde som går till närmaste jämnt heltal,
  • ROUND_HALF_UP: den kommer att avrunda till närmaste med ett värde som går från noll
  • ROUND_UP: det kommer att avrundas där värdet går bort från noll.

I decimal hjälper metoden quantize () att runda till ett fast antal decimaler, och du kan ange den avrundning som ska användas, som visas i exemplet nedan.

Exempel:

Använda runda () och decimala metoder

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)

Produktion:

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

Sammanfattning:

  • Round (float_num, Num_of_decimals) är en inbyggd funktion som finns med python. Det ger dig flottörnumret som kommer att avrundas till decimalerna som anges som inmatning.
  • float_num: flottörnumret som ska avrundas.
  • Num_of_decimals: Det är antalet decimaler som ska beaktas vid avrundning.
  • Det returnerar ett heltal om num_of_decimals inte ges och ett float-värde om num_of_decimals ges.