Python round () functie met VOORBEELDEN

Inhoudsopgave:

Anonim

Ronde()

Round () is een ingebouwde functie die beschikbaar is met python. Het zal u een float-getal retourneren dat wordt afgerond op de decimalen die als invoer zijn opgegeven.

Als de af te ronden decimalen niet zijn opgegeven, wordt dit als 0 beschouwd en wordt afgerond naar het dichtstbijzijnde gehele getal.

In deze Python-zelfstudie leer je:

  • Ronde()
  • Syntaxis:
  • Hoeveel impact kan afronding hebben? (Afronden versus afkappen)
  • Voorbeeld: Float-getallen afronden
  • Voorbeeld: waarden van gehele getallen afronden
  • Voorbeeld: afronden op negatieve getallen
  • Voorbeeld: ronde numpy arrays
  • Voorbeeld: Decimale module

Syntaxis:

round(float_num, num_of_decimals)

Parameters

  • float_num: het float-getal dat moet worden afgerond.
  • aantal_decimalen: (optioneel) Het aantal decimalen waarmee rekening moet worden gehouden bij het afronden. Het is optioneel, en indien niet gespecificeerd, is het standaard 0, en wordt afgerond op het dichtstbijzijnde gehele getal.

Omschrijving

De methode round () heeft twee argumenten

  • het aantal dat moet worden afgerond en
  • de decimalen waarmee rekening moet worden gehouden bij het afronden.

Het tweede argument is optioneel en staat standaard op 0 als het niet wordt gespecificeerd, en in dat geval wordt het afgerond op het dichtstbijzijnde gehele getal, en het retourtype is ook een geheel getal.

Als de decimalen, dus het tweede argument, aanwezig zijn, wordt afgerond op het aantal opgegeven plaatsen. Het retourtype is een float.

Als het nummer achter de komma wordt gegeven

  • > = 5 dan + 1 wordt opgeteld bij de uiteindelijke waarde
  • <5 dan wordt de uiteindelijke waarde geretourneerd aangezien het tot aan de vermelde decimalen is.

Winstwaarde

Het zal een geheel getal teruggeven als het aantal_decimalen niet is gegeven en een zwevende waarde als het aantal_decimalen is opgegeven. Houd er rekening mee dat de waarde wordt afgerond op +1 als de waarde achter de komma> = 5 is, anders wordt de waarde geretourneerd zoals deze is tot aan de vermelde decimalen.

Hoeveel impact kan afronding hebben? (Afronden versus afkappen)

Het beste voorbeeld om de impact van afronding aan te tonen is voor de beursmarkt. In het verleden, dwz in het jaar 1982, de Vancouver Stock Exchange (VSE): werd gebruikt om de aandelenwaarden af ​​te kappen tot op drie decimalen van elke transactie.

Het werd elke dag bijna 3000 keer gedaan. De geaccumuleerde afkortingen leiden tot een verlies van ongeveer 25 punten per maand.

Een voorbeeld van het afkappen van de waarden versus afronding wordt hieronder weergegeven.

Beschouw de drijvende-kommagetallen die hieronder worden gegenereerd als aandelenwaarden. Op dit moment genereer ik het voor een reeks

1.000.000 seconden tussen 0,01 en 0,05.

Voorbeelden:

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

Om de impact van afronding te laten zien, heb ik een klein stukje code geschreven waarin je in eerste instantie de getallen tot slechts 3 decimalen hoeft te gebruiken, dwz het aantal afkappen na 3 decimalen.

Ik heb de oorspronkelijke totale waarde, het totaal afkomstig van afgekapte waarden en het verschil tussen de oorspronkelijke en afgekapte waarde.

Op dezelfde reeks getallen heb ik de methode round () tot 3 decimalen gebruikt en de som en het verschil tussen de oorspronkelijke waarde en de afgeronde waarde berekend.

Hier zijn het voorbeeld en de output

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

Uitgang:

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

Het verschil tussen origineel en na afkappen is 499,9016193868665 en vanaf rond is 0,04661938686695066

Het verschil lijkt erg groot te zijn, en het voorbeeld laat zien hoe de methode round () helpt bij het berekenen van bijna nauwkeurigheid.

Voorbeeld: Float-getallen afronden

In dit programma zullen we zien hoe het afronden van woorden op zwevende getallen

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

Uitgang:

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

Voorbeeld: waarden van gehele getallen afronden

Als je toevallig round () gebruikt voor een geheel getal, zal het je het getal teruggeven zonder enige wijzigingen.

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

Uitgang:

The output is 15

Voorbeeld: afronden op negatieve getallen

Laten we enkele voorbeelden bekijken van hoe afronden werkt op negatieve getallen

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

Uitgang:

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

Voorbeeld: ronde numpy arrays

Hoe numpy arrays in python rond te maken?

Om dit op te lossen, kunnen we gebruik maken van de numpy module en de numpy.round () of numpy.around () methode gebruiken, zoals getoond in het onderstaande voorbeeld.

Numpy.round () gebruiken

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

Uitgang:

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

We kunnen ook numpy.around () gebruiken, wat hetzelfde resultaat geeft als in het onderstaande voorbeeld.

Voorbeeld: Decimale module

Naast de functie round () heeft python een decimale module die helpt bij het nauwkeuriger omgaan met decimale getallen.

De Decimale module wordt geleverd met afrondingen, zoals hieronder weergegeven:

  • ROUND_CEILING: het zal zich afronden in de richting van oneindigheid,
  • ROUND_DOWN: het rondt de waarde af naar nul,
  • ROUND_FLOOR: het zal afronden naar -Infinity,
  • ROUND_HALF_DOWN: het wordt afgerond op de dichtstbijzijnde waarde in de richting van nul,
  • ROUND_HALF_EVEN: het wordt afgerond naar het dichtstbijzijnde waarbij de waarde naar het dichtstbijzijnde even gehele getal gaat,
  • ROUND_HALF_UP: het wordt afgerond naar het dichtstbijzijnde waarbij de waarde weggaat van nul
  • ROUND_UP: het wordt afgerond waar de waarde weggaat van nul.

Als decimaal getal helpt de methode quantize () om af te ronden op een vast aantal decimalen, en u kunt de afronding specificeren die moet worden gebruikt, zoals weergegeven in het onderstaande voorbeeld.

Voorbeeld:

Met behulp van round () en decimale methoden

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)

Uitgang:

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

Overzicht:

  • Round (float_num, Num_of_decimals) is een ingebouwde functie die beschikbaar is met python. Het geeft u het float-getal dat wordt afgerond op de decimalen die als invoer zijn opgegeven.
  • float_num: het float-getal dat moet worden afgerond.
  • Num_of_decimals: Het is het aantal decimalen waarmee rekening moet worden gehouden bij het afronden.
  • Het zal een geheel getal teruggeven als het aantal_decimalen niet is gegeven en een zwevende waarde als het aantal_decimalen is opgegeven.