파이썬 반올림 구현 - paisseon ban-ollim guhyeon

Question

목적

알고리즘 문제 풀이 시 숫자를 다룰 때, ~ 번째 자리에서 주로 반올림을 하고, 이 값을 구하는 문제가 있다. 또한 올림, 내림, 버림 형태는 파이썬에서 어떻게 다뤄야할 지 알아보도록 하자.

목차 Show

반올림(Round)
[Python] 내장함수 round 구현
사사오입 방식의 반올림 구현 : decimal 모듈 사용
※ 주의점!!! : round 함수의 매개변수가 하나일 때
round 함수의 매개변수가 두 개일 때
※ 궁금한 부분, 이상한 점 및 오타는 댓글에 부탁드립니다.

반올림(Round)

파이썬 반올림은 내장함수 round(number[, ndigits])로 number를 소수점 다음에 ndigits 정밀도로 반올림한 값을 돌려준다.

>>> round(1234.233)
1234

>>> round(1234.233,2)
1234.23

첫 번째 결과는 몇 번째 자리까지 계산할지 정하지 않았는 데, 이때는 첫 번째 자리에서 반올림하게 된다. 따라서 1234 값을 얻게 되었다.

두 번째 결과는 둘째자리까지 계산하고, 즉 셋째 자리에서 반올림하므로 1234.23이라는 결과가 나오게 되었다.

아래는 한 가지 주의해야 할 점으로, 1.5와 2.5의 반올림 값이 다르다는 것이다. 1.5는 2가 되었고, 2.5는 2가 되었다.

>>> round(1.5)
2   
>>> round(2.5)
2

이는 파이썬 계산이 Round half to even (Gaussian Rounding, Banker's Rounding) 방식을 따르기 때문이다.

즉, 중간값인 1.5, 2.5 등등은 짝수인 정수로 반올림된다.

- 1.5를 Round half to even 반올림한다면 2 (홀수인 1에 0.5인 값인 1.5의 경우 홀수에서 짝수인 정수 2로 반올림)

- 2.5를 Round half to even 반올림한다면 2 (짝수인 2에 0.5인 값인 2.5의 경우 홀수에서 짝수인 정수 2로 반올림)

물론 값이 1.4인 경우는 1로 반올림되고, 2.6인 경우는 3으로 반올림된다.

그럼 왜 이러한 반올림을 사용할까?

기존 반올림 대비 Round half to even은 합과 평균을 근사할 때 편향을 줄일 수 있는 장점이 있다.

예를 들어, 나열된 수에 대해 반올림한 합 또는 평균을 구한다고 하였을 때, 0.5 값을 많이 가지는 수가 나열되었다고 하면 결과값에서 큰 차이가 난다.

e.g.) 1.5+2.5+3.5=7.5

각 숫자 1의 자리에서 반올림 하는 경우, 2+3+4=9

이 때 Round half to even 방식을 사용하면, 2+2+3=7와 같이 근사 오차를 줄일 수 있다.

따라서 파이썬 반올림은 이 방식을 채택하여 계산하고 있다고 생각하면 된다.

올림 (Ceil)

올림은 해당 값에서 양의 무한대 방향으로 가까운 정수를 선택한다.

여기서부터는 내장 함수가 아닌 math 라이브러리를 사용해야 한다. ceil() 함수를 통해 해당 값을 올림한다. 결과는 아래와 같다.

>>> import math
>>> math.ceil(1.5)
2
>>> math.ceil(-1.5)
-1

내림 (Floor)

내림은 해당 값에서 음의 무한대 방향으로 가까운 정수를 선택한다.

내장 함수가 아닌 math 라이브러리를 사용해야 한다. floor() 함수를 통해 해당 값을 내림한다. 결과는 아래와 같다.

>>> math.floor(1.5)
1
>>> math.floor(-1.5)
-2

버림(Trunc)

버림은 해당 값에서 0에 가까운 정수를 선택한다.

내장 함수가 아닌 math 라이브러리를 사용해야 한다. trunc() 함수를 통해 해당 값을 버림한다. 결과는 아래와 같다.

>>> math.trunc(1.5)
1
>>> math.trunc(-1.5)
-1

a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
======  ======  =====  =====  =====
  -3      -1      0      2      3   Round (기존 반올림)                
  -3       0      0      2      3   Round (Round half to even)     
  -2       0      1      2      3   Ceiling (올림)                
  -3      -1      0      1      2   Floor (내림)                  
  -2       0      0      1      2   Truncate (버림)

Reference

.net - Difference between Math.Floor() and Math.Truncate() - Stack Overflow

Studying/Python

[Python] 내장함수 round 구현

giem 2022. 5. 15. 00:40

Python에서 반올림을 필요로 하는 상황이 많다

우선 round 함수의 사용법을 보겠다

test = 1.74789

print(round(test))	#2
print(round(test, 3))	#1.748
print(round(-test, 2))	#-1.75

위의 예제처럼

첫 번째 인자에 반올림 할 수가 들어가고 두 번째 인자는 몇 번째 자리까지 사용할 건지에 대한 옵션이다.

두번째 인자가 들어가지 않거나 None이면 입력에 가장 가까운 정수로 반환한다

여기서 사용할 수식중 제곱연산과 나머지 연산에 대한 예시는 다음과 같다.

# 제곱 연산은 ** 연산자로 계산할 수 있다.
10 ** 2 == 100

# mod(나머지 연산)는 % 연산자로 계산할 수 있다.
5 % 2 == 1

위 정보들을 토대로 설계해보겠다.

우선 두번째 인자가 None일때는 0으로 초기화하고 시작한다.

그 후 1번째 인자에 2번째 인자에서 값을 준 만큼 소수점 자리를 옮겨서 뒤를 버리고

올림, 내림을 한 뒤 원래의 소수점 자리로 돌아오게 해준다.

설명이 어려운데 직접 코드로 보면 다음과 같다.

def my_round(number, ndgits=None):
  if ndgits is None:	#값 없을 시 0 초기화
    ndgits = 0
    
  mult = 10 ** (ndgits + 1)	# 소수점 자리 옮기기 위해 생성(10의 n승을 구함)
  eff = int(number * mult)	# 소수점 자리 버림

  if eff % 10 >=5:	# %연산으로 끝자리만 남긴 후 올림/내림 여부 판단
    eff += (10-eff%10)
  else:
    eff -= eff%10
  
  number = eff /mult # 원래의 소수점 자리로 돌려놓기

  return number

이해에 도움이 되도록 라인마다 comment를 써놓았다.

잘 구현되었는지 테스트를 해보면

test = 1.74789

assert round(test) == my_round(test)
assert round(test, 3) == my_round(test, 3)
assert round(-test, 2) == my_round(-test, 2)

잘 동작하는 것을 볼 수 있다.

2021.05.13 - [프로그래밍/Python] - [Python] round 함수 : 반올림 (1) - 사용 방법

2021.05.15 - [프로그래밍/Python] - [Python] round 함수 : 반올림 (2) - 예상과는 다른 결과

[Python] round 함수 : 반올림 (2) - 예상과는 다른 결과

이전에 파이썬에서 반올림을 할 때 사용하는 함수 round에 대해 포스팅해봤습니다. 그런데, 이 round 함수는 우리가 일반적으로 알고 있는 결과와 다르게 나올 때가 있습니다. 다음은 우리가 알고

brightnightsky77.tistory.com

이전 포스팅에서는 우리가 알고 있는 반올림과는 다른 결과를 출력하는 파이썬의 round 함수에 대해서 알아봤습니다.

그런데 밑의 링크의 문제와 같이 파이썬의 round 함수에서 사용되는 오사오입 방식의 반올림이 아닌

우리가 일상생활에서 사용하는 사사오입 방식의 반올림 결과를 요구하는 문제들도 있습니다.

[백준][solved.ac][Silver 4][Python] 18110번 : solved.ac

밑의 링크는 백준에서의 문제 링크입니다. 18110번: solved.ac 5명의 15%는 0.75명으로, 이를 반올림하면 1명이다. 따라서 solved.ac는 가장 높은 난이도 의견과 가장 낮은 난이도 의견을 하나씩 제외하고

brightnightsky77.tistory.com

이번에는 우리가 알고 있는 반올림인 사사오입 방식의 반올림을 파이썬에서 구현하는 방법에 알아보겠습니다.

사사오입 방식의 반올림 구현 : decimal 모듈 사용

decimal 모듈은 정확한 십진법 산술을 위한 모듈입니다.

decimal 모듈의 context 객체에서 자리 올림 모드를 변경하여 사사오입 방식의 반올림을 사용할 수 있습니다.

밑의 링크는 decimal 모듈에 대한 파이썬 공식 문서 페이지입니다.

decimal — 십진 고정 소수점 및 부동 소수점 산술 — Python 3.9.5 문서

decimal 모듈은 빠르고 정확하게 자리 올림 하는 십진 부동 소수 산술을 지원합니다. float 데이터형보다 다음과 같은 몇 가지 장점을 제공합니다: 모듈 설계의 중심 개념은 세 가지입니다: 십진수,

docs.python.org

밑의 코드를 선언하면 decimal 모듈의 round 함수의 첫 번째 매개변수인 반올림을 할 숫자 매개변수에

Decimal 객체를 사용하여 숫자를 넣으면, 사사오입 방식의 반올림을 사용할 수 있습니다.

# decimal 모듈을 import합니다.
import decimal

# 산술 연산을 위한 환경을 불러옵니다.
context = decimal.getcontext()

# 반올림 방식을 사사오입 방식으로 변경해줍니다.
# 파이썬 기존의 반올림 방식인 오사오입 반올림은 decimal.ROUND_HALF_EVEN입니다.
context.rounding = decimal.ROUND_HALF_UP

※ 주의점!!! : round 함수의 매개변수가 하나일 때

round 함수에 매개변수를 하나만 넣으면 decimal 모듈을 써서

반올림 모드를 변경해도 사사오입 반올림이 적용되지 않습니다.

만약, 소수점 첫째 자리에서 반올림만을 고려해 round 함수에 하나의 매개변수만 사용할 생각이더라도

무조건 정밀도까지 표현하는 매개변수 2개인 round 함수를 사용해야합니다.

밑의 코드와 결과는 decimal 모듈을 사용하여 사사오입 방식의 반올림으로 설정한 후,

round 함수에 매개변수를 하나만 넣어본 결과입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# 0.5의 소수점 첫째 자리에서 반올림하여 1이 나올 것으로 예상해봅니다.
# 그런데 0이 나옵니다.
print("0.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.5')))

# 1.5의 소수점 첫째 자리에서 반올림하여 2가 나올 것으로 예상해봅니다.
# 예상대로 2가 나옵니다.
print("1.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('1.5')))

# 2.5의 소수점 첫째 자리에서 반올림하여 3이 나올 것으로 예상해봅니다.
# 그런데 2가 나옵니다.
print("2.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('2.5')))

# 3.5의 소수점 첫째 자리에서 반올림하여 4가 나올 것으로 예상해봅니다.
# 예상대로 4가 나옵니다.
print("3.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('3.5')))

# 4.5의 소수점 첫째 자리에서 반올림하여 5가 나올 것으로 예상해봅니다.
# 그런데 4가 나옵니다.
print("4.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('4.5')))

print("\n---------------------------------------------------\n")

# -0.5의 소수점 첫째 자리에서 반올림하여 -1이 나올 것으로 예상해봅니다.
# 그런데 0이 나옵니다.
print("-0.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.5')))

# -1.5의 소수점 첫째 자리에서 반올림하여 -2가 나올 것으로 예상해봅니다.
# 예상대로 -2가 나옵니다.
print("-1.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-1.5')))

# -2.5의 소수점 첫째 자리에서 반올림하여 -3이 나올 것으로 예상해봅니다.
# 그런데 -2가 나옵니다.
print("-2.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-2.5')))

# -3.5의 소수점 첫째 자리에서 반올림하여 -4가 나올 것으로 예상해봅니다.
# 예상대로 -4가 나옵니다.
print("-3.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-3.5')))

# -4.5의 소수점 첫째 자리에서 반올림하여 -5가 나올 것으로 예상해봅니다.
# 그런데 -4가 나옵니다.
print("-4.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-4.5')))

decimal 모듈을 사용해도 round 함수에 매개변수가 1개면 사사오입 방식의 반올림이 적용되지 않는 결과

round 함수의 매개변수가 두 개일 때

1. 양수

1-1. 양의 정수

밑의 코드와 결과는 양의 정수의 일의 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# 5의 일의 자리에서 사사오입 반올림하여 10이 나올 것으로 예상해봅니다.
# 예상대로 10이 나옵니다.
print("5의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('5'), -1))
print("반환 형식:", type(round(decimal.Decimal('5'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('5'), -1))
print()

# 15의 일의 자리에서 사사오입 반올림하여 20이 나올 것으로 예상해봅니다.
# 예상대로 20이 나옵니다.
print("15의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('15'), -1))
print("반환 형식:", type(round(decimal.Decimal('15'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('15'), -1))
print()

# 25의 일의 자리에서 사사오입 반올림하여 30이 나올 것으로 예상해봅니다.
# 예상대로 30이 나옵니다.
print("25의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('25'), -1))
print("반환 형식:", type(round(decimal.Decimal('25'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('25'), -1))
print()

# 35의 일의 자리에서 사사오입 반올림하여 40이 나올 것으로 예상해봅니다.
# 예상대로 40이 나옵니다.
print("35의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('35'), -1))
print("반환 형식:", type(round(decimal.Decimal('35'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('35'), -1))
print()

# 45의 일의 자리에서 사사오입 반올림하여 50이 나올 것으로 예상해봅니다.
# 예상대로 50이 나옵니다.
print("45의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('45'), -1))
print("반환 형식:", type(round(decimal.Decimal('45'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('45'), -1))

양의 정수의 일의 자리에서 사사오입 반올림한 결과

밑의 코드와 결과는 양의 정수의 십의 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# 50의 십의 자리에서 사사오입 반올림하여 100이 나올 것으로 예상해봅니다.
# 예상대로 100이 나옵니다.
print("50의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('50'), -2))
print("반환 형식:", type(round(decimal.Decimal('50'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('50'), -2))
print()

# 150의 십의 자리에서 사사오입 반올림하여 200이 나올 것으로 예상해봅니다.
# 예상대로 200이 나옵니다.
print("150의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('150'), -2))
print("반환 형식:", type(round(decimal.Decimal('150'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('150'), -2))
print()

# 250의 십의 자리에서 사사오입 반올림하여 300이 나올 것으로 예상해봅니다.
# 예상대로 300이 나옵니다.
print("250의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('250'), -2))
print("반환 형식:", type(round(decimal.Decimal('250'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('250'), -2))
print()

# 350의 십의 자리에서 사사오입 반올림하여 400이 나올 것으로 예상해봅니다.
# 예상대로 400이 나옵니다.
print("350의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('350'), -2))
print("반환 형식:", type(round(decimal.Decimal('350'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('350'), -2))
print()

# 450의 십의 자리에서 사사오입 반올림하여 500이 나올 것으로 예상해봅니다.
# 예상대로 500이 나옵니다.
print("450의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('450'), -2))
print("반환 형식:", type(round(decimal.Decimal('450'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('450'), -2))

양의 정수의 십의 자리에서 사사오입 반올림한 결과

1-2. 양의 소수

밑의 코드와 결과는 양의 소수의 소수점 첫째 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# 0.5의 소수점 첫째 자리에서 사사오입 반올림하여 1이 나올 것으로 예상해봅니다.
# 예상대로 1이 나옵니다.
print("0.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('0.5'), 0)))
print()

# 1.5의 소수점 둘째 자리에서 사사오입 반올림하여 2가 나올 것으로 예상해봅니다.
# 예상대로 2가 나옵니다.
print("1.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('1.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('1.5'), 0)))
print()

# 2.5의 소수점 첫째 자리에서 사사오입 반올림하여 3이 나올 것으로 예상해봅니다.
# 예상대로 3이 나옵니다.
print("2.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('2.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('2.5'), 0)))
print()

# 3.5의 소수점 첫째 자리에서 사사오입 반올림하여 4가 나올 것으로 예상해봅니다.
# 예상대로 4가 나옵니다.
print("3.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('3.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('3.5'), 0)))
print()

# 4.5의 소수점 첫째 자리에서 사사오입 반올림하여 5가 나올 것으로 예상해봅니다.
# 예상대로 5가 나옵니다.
print("4.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('4.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('4.5'), 0)))

양의 소수의 소수점 첫째 자리에서 사사오입 반올림한 결과

밑의 코드와 결과는 양의 소수의 소수점 둘째 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# 0.05의 소수점 둘째 자리에서 사사오입 반올림하여 0.1이 나올 것으로 예상해봅니다.
# 예상대로 0.1이 나옵니다.
print("0.05의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.05'), 1))
print("반환 형식:", type(round(decimal.Decimal('0.05'), 1)))
print()

# 0.15의 소수점 둘째 자리에서 사사오입 반올림하여 0.2가 나올 것으로 예상해봅니다.
# 예상대로 0.2가 나옵니다.
print("0.15의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.15'), 1))
print("반환 형식:", type(round(decimal.Decimal('0.15'), 1)))
print()

# 0.25의 소수점 둘째 자리에서 사사오입 반올림하여 0.3이 나올 것으로 예상해봅니다.
# 예상대로 0.3이 나옵니다.
print("0.25의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.25'), 1))
print("반환 형식:", type(round(decimal.Decimal('0.25'), 1)))
print()

# 0.35의 소수점 둘째 자리에서 사사오입 반올림하여 0.4가 나올 것으로 예상해봅니다.
# 예상대로 0.4가 나옵니다.
print("0.35의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.35'), 1))
print("반환 형식:", type(round(decimal.Decimal('0.35'), 1)))
print()

# 0.45의 소수점 둘째 자리에서 사사오입 반올림하여 0.5가 나올 것으로 예상해봅니다.
# 예상대로 0.5가 나옵니다.
print("0.45의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('0.45'), 1))
print("반환 형식:", type(round(decimal.Decimal('0.45'), 1)))

양의 소수의 소수점 둘째 자리에서 사사오입 반올림한 결과

2. 음수

2-1. 음의 정수

밑의 코드와 결과는 음의 정수의 일의 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# -5의 일의 자리에서 사사오입 반올림하여 -10이 나올 것으로 예상해봅니다.
# 예상대로 -10이 나옵니다.
print("-5의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-5'), -1))
print("반환 형식:", type(round(decimal.Decimal('-5'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-5'), -1))
print()

# -15의 일의 자리에서 사사오입 반올림하여 -20이 나올 것으로 예상해봅니다.
# 예상대로 -20이 나옵니다.
print("-15의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-15'), -1))
print("반환 형식:", type(round(decimal.Decimal('-15'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-15'), -1))
print()

# -25의 일의 자리에서 사사오입 반올림하여 -30이 나올 것으로 예상해봅니다.
# 예상대로 -30이 나옵니다.
print("-25의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-25'), -1))
print("반환 형식:", type(round(decimal.Decimal('-25'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-25'), -1))
print()

# -35의 일의 자리에서 사사오입 반올림하여 -40이 나올 것으로 예상해봅니다.
# 예상대로 -40이 나옵니다.
print("-35의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-35'), -1))
print("반환 형식:", type(round(decimal.Decimal('-35'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-35'), -1))
print()

# -45의 일의 자리에서 사사오입 반올림하여 -50이 나올 것으로 예상해봅니다.
# 예상대로 -50이 나옵니다.
print("-45의 일의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-45'), -1))
print("반환 형식:", type(round(decimal.Decimal('-45'), -1)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-45'), -1))

음의 정수의 일의 자리에서 사사오입 반올림한 결과

밑의 코드와 결과는 음의 정수의 십의 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# -50의 십의 자리에서 사사오입 반올림하여 -100이 나올 것으로 예상해봅니다.
# 예상대로 -100이 나옵니다.
print("-50의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-50'), -2))
print("반환 형식:", type(round(decimal.Decimal('-50'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-50'), -2))
print()

# -150의 십의 자리에서 사사오입 반올림하여 -200이 나올 것으로 예상해봅니다.
# 예상대로 -200이 나옵니다.
print("-150의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-150'), -2))
print("반환 형식:", type(round(decimal.Decimal('-150'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-150'), -2))
print()

# -250의 십의 자리에서 사사오입 반올림하여 -300이 나올 것으로 예상해봅니다.
# 예상대로 -300이 나옵니다.
print("-250의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-250'), -2))
print("반환 형식:", type(round(decimal.Decimal('-250'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-250'), -2))
print()

# -350의 십의 자리에서 사사오입 반올림하여 -400이 나올 것으로 예상해봅니다.
# 예상대로 -400이 나옵니다.
print("-350의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-350'), -2))
print("반환 형식:", type(round(decimal.Decimal('-350'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-350'), -2))
print()

# -450의 십의 자리에서 사사오입 반올림하여 -500이 나올 것으로 예상해봅니다.
# 예상대로 -500이 나옵니다.
print("-450의 십의 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-450'), -2))
print("반환 형식:", type(round(decimal.Decimal('-450'), -2)))
print("지수 표현없이 출력하기:", "%d" % round(decimal.Decimal('-450'), -2))

음의 정수의 십의 자리에서 사사오입 반올림한 결과

2-2. 음의 소수

밑의 코드와 결과는 음의 소수의 소수점 첫째 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# -0.5의 소수점 첫째 자리에서 사사오입 반올림하여 -1이 나올 것으로 예상해봅니다.
# 예상대로 -1이 나옵니다.
print("-0.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('-0.5'), 0)))
print()

# -1.5의 소수점 첫째 자리에서 사사오입 반올림하여 -2가 나올 것으로 예상해봅니다.
# 예상대로 -2가 나옵니다.
print("-1.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-1.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('-1.5'), 0)))
print()

# -2.5의 소수점 첫째 자리에서 사사오입 반올림하여 -3이 나올 것으로 예상해봅니다.
# 예상대로 -3이 나옵니다.
print("-2.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-2.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('-2.5'), 0)))
print()

# -3.5의 소수점 첫째 자리에서 사사오입 반올림하여 -4가 나올 것으로 예상해봅니다.
# 예상대로 -4가 나옵니다.
print("-3.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-3.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('-3.5'), 0)))
print()

# -4.5의 소수점 첫째 자리에서 사사오입 반올림하여 -5가 나올 것으로 예상해봅니다.
# 예상대로 -5가 나옵니다.
print("-4.5의 소수점 첫째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-4.5'), 0))
print("반환 형식:", type(round(decimal.Decimal('-4.5'), 0)))

음의 소수의 소수점 첫째 자리에서 사사오입 반올림한 결과

밑의 코드와 결과는 음의 소수의 소수점 둘째 자리에서 사사오입 반올림한 것입니다.

import decimal

# 사사오입 방식의 반올림을 사용하기 위해 설정해줍니다.
context = decimal.getcontext()
context.rounding = decimal.ROUND_HALF_UP

# -0.05의 소수점 둘째 자리에서 사사오입 반올림하여 -0.1이 나올 것으로 예상해봅니다.
# 예상대로 -0.1이 나옵니다.
print("-0.05의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.05'), 1))
print("반환 형식:", type(round(decimal.Decimal('-0.05'), 1)))
print()

# -0.15의 소수점 둘째 자리에서 사사오입 반올림하여 -0.2가 나올 것으로 예상해봅니다.
# 예상대로 -0.2가 나옵니다.
print("-0.15의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.15'), 1))
print("반환 형식:", type(round(decimal.Decimal('-0.15'), 1)))
print()

# -0.25의 소수점 둘째 자리에서 사사오입 반올림하여 -0.3이 나올 것으로 예상해봅니다.
# 예상대로 -0.3이 나옵니다.
print("-0.25의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.25'), 1))
print("반환 형식:", type(round(decimal.Decimal('-0.25'), 1)))
print()

# -0.35의 소수점 둘째 자리에서 사사오입 반올림하여 -0.4가 나올 것으로 예상해봅니다.
# 예상대로 -0.4가 나옵니다.
print("-0.35의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.35'), 1))
print("반환 형식:", type(round(decimal.Decimal('-0.35'), 1)))
print()

# -0.45의 소수점 둘째 자리에서 사사오입 반올림하여 -0.5가 나올 것으로 예상해봅니다.
# 예상대로 -0.5가 나옵니다.
print("-0.45의 소수점 둘째 자리에서 사사오입 반올림한 결과:", round(decimal.Decimal('-0.45'), 1))
print("반환 형식:", type(round(decimal.Decimal('-0.45'), 1)))

음의 소수의 소수점 둘째 자리에서 사사오입 반올림한 결과