ਪਾਇਥਨ ਵਿੱਚ ਦਸ਼ਮਲਵ ਅਤੇ ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ “round” ਅਤੇ “decimal.quantize” ਨਾਲ ਗੋਲ ਕਰਨਾ

ਕਾਰੋਬਾਰ

ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ ਕਿ ਪਾਇਥਨ ਵਿੱਚ ਸੰਖਿਆਵਾਂ ਨੂੰ ਇੱਕ ਬਰਾਬਰ ਸੰਖਿਆ ਵਿੱਚ ਗੋਲ ਜਾਂ ਗੋਲ ਕਰਕੇ ਕਿਵੇਂ ਗੋਲ ਕਰਨਾ ਹੈ। ਸੰਖਿਆਵਾਂ ਨੂੰ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਫਲੋਟ ਜਾਂ ਪੂਰਨ ਅੰਕ ਇੰਟ ਕਿਸਮ ਦਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

  • ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ):round()
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਗੋਲ।
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਗੋਲ ਪੂਰਨ ਅੰਕ।
    • round() ਇੱਕ ਸਮ ਸੰਖਿਆ ਲਈ ਗੇੜ, ਨਾ ਕਿ ਇੱਕ ਆਮ ਰਾਊਂਡਿੰਗ ਲਈ
  • ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀdecimalquantize()
    • Decimalਇੱਕ ਵਸਤੂ ਬਣਾਉਣਾ
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਦਾ ਗੋਲਾਕਾਰ ਅਤੇ ਸਮ ਸੰਖਿਆਵਾਂ ਲਈ ਪੂਰਨ ਅੰਕ
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਗੋਲਾਕਾਰ ਅਤੇ ਸਮ ਸੰਖਿਆਵਾਂ ਦਾ ਪੂਰਨ ਅੰਕ
  • ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਨੂੰ ਗੋਲ ਕਰੋ।
    • ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਗੋਲ ਪੂਰਨ ਅੰਕ
    • ਨੋਟ: ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਲਈ

ਨੋਟ ਕਰੋ ਕਿ, ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਰਾਉਂਡ ਇੱਕ ਆਮ ਰਾਊਂਡਿੰਗ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਸਮ ਸੰਖਿਆ ਲਈ ਇੱਕ ਰਾਊਂਡਿੰਗ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਹੇਠਾਂ ਦੇਖੋ।

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ):round()

ਰਾਉਂਡ() ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਕਿਸੇ ਵੀ ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕੀਤੇ ਬਿਨਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਅਸਲ ਸੰਖਿਆ ਹੈ, ਅਤੇ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਹੈ (ਕਿੰਨ੍ਹੇ ਅੰਕਾਂ ਨੂੰ ਗੋਲ ਕਰਨਾ ਹੈ)।

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਗੋਲ।

ਹੇਠਾਂ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਫਲੋਟ ਕਿਸਮ ਲਈ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ।

ਜੇਕਰ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਕਿਸਮ ਵੀ ਇੱਕ ਪੂਰਨ ਅੰਕ ਇੰਟ ਕਿਸਮ ਬਣ ਜਾਂਦੀ ਹੈ।

f = 123.456

print(round(f))
# 123

print(type(round(f)))
# <class 'int'>

ਜੇਕਰ ਦੂਜਾ ਆਰਗੂਮੈਂਟ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਫਲੋਟ ਕਿਸਮ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਜੇਕਰ ਇੱਕ ਸਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਦਸ਼ਮਲਵ ਸਥਾਨ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ; ਜੇਕਰ ਇੱਕ ਨਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪੂਰਨ ਅੰਕ ਸਥਾਨ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨਜ਼ਦੀਕੀ ਦਸਵੇਂ ਤੱਕ -1 ਗੇੜ, ਨਜ਼ਦੀਕੀ ਸੌਵੇਂ ਤੱਕ -2 ਗੇੜ, ਅਤੇ ਇੱਕ ਪੂਰਨ ਅੰਕ (ਪਹਿਲੇ ਸਥਾਨ) ਲਈ 0 ਗੇੜ, ਪਰ ਇੱਕ ਫਲੋਟ ਕਿਸਮ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ।

print(round(f, 1))
# 123.5

print(round(f, 2))
# 123.46

print(round(f, -1))
# 120.0

print(round(f, -2))
# 100.0

print(round(f, 0))
# 123.0

print(type(round(f, 0)))
# <class 'float'>

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਗੋਲ ਪੂਰਨ ਅੰਕ।

ਹੇਠਾਂ ਪੂਰਨ ਅੰਕ ਇੰਟ ਕਿਸਮ ਲਈ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ।

ਜੇਕਰ ਦੂਸਰਾ ਆਰਗੂਮੈਂਟ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਜਾਂ ਜੇਕਰ 0 ਜਾਂ ਇੱਕ ਸਕਾਰਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅਸਲ ਮੁੱਲ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਹੈ। ਜੇਕਰ ਇੱਕ ਨੈਗੇਟਿਵ ਪੂਰਨ ਅੰਕ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਸੰਬੰਧਿਤ ਪੂਰਨ ਅੰਕ ਅੰਕ ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਇੱਕ ਪੂਰਨ ਅੰਕ ਇੰਟ ਕਿਸਮ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

i = 99518

print(round(i))
# 99518

print(round(i, 2))
# 99518

print(round(i, -1))
# 99520

print(round(i, -2))
# 99500

print(round(i, -3))
# 100000

round() ਇੱਕ ਸਮ ਸੰਖਿਆ ਲਈ ਗੇੜ, ਨਾ ਕਿ ਇੱਕ ਆਮ ਰਾਊਂਡਿੰਗ ਲਈ

ਨੋਟ ਕਰੋ ਕਿ ਪਾਈਥਨ 3 ਵਿੱਚ ਬਿਲਟ-ਇਨ round() ਫੰਕਸ਼ਨ ਦੇ ਨਾਲ ਰਾਊਂਡਿੰਗ ਇੱਕ ਸਮ ਸੰਖਿਆ ਵਿੱਚ ਹੁੰਦੀ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਆਮ ਰਾਊਂਡਿੰਗ ਵਿੱਚ।

ਜਿਵੇਂ ਕਿ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, 0.5 ਨੂੰ 0 ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਗਿਆ ਹੈ, 5 ਨੂੰ 0 ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੀ।

print('0.4 =>', round(0.4))
print('0.5 =>', round(0.5))
print('0.6 =>', round(0.6))
# 0.4 => 0
# 0.5 => 0
# 0.6 => 1

print('4 =>', round(4, -1))
print('5 =>', round(5, -1))
print('6 =>', round(6, -1))
# 4 => 0
# 5 => 0
# 6 => 10

ਇੱਕ ਸਮ ਸੰਖਿਆ ਨੂੰ ਗੋਲ ਕਰਨ ਦੀ ਪਰਿਭਾਸ਼ਾ ਇਸ ਪ੍ਰਕਾਰ ਹੈ।

ਜੇ ਫਰੈਕਸ਼ਨ 0.5 ਤੋਂ ਘੱਟ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਹੇਠਾਂ ਗੋਲ ਕਰੋ; ਜੇਕਰ ਫਰੈਕਸ਼ਨ 0.5 ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਗੋਲ ਕਰੋ; ਜੇਕਰ ਅੰਸ਼ ਬਿਲਕੁਲ 0.5 ਹੈ, ਤਾਂ ਇਸਨੂੰ ਹੇਠਾਂ ਵੱਲ ਅਤੇ ਉੱਪਰ ਨੂੰ ਗੋਲ ਕਰਨ ਦੇ ਵਿਚਕਾਰ ਬਰਾਬਰ ਸੰਖਿਆ ਤੱਕ ਗੋਲ ਕਰੋ।
Rounding – Wikipedia

0.5 ਨੂੰ ਹਮੇਸ਼ਾ ਕੱਟਿਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ।

print('0.5 =>', round(0.5))
print('1.5 =>', round(1.5))
print('2.5 =>', round(2.5))
print('3.5 =>', round(3.5))
print('4.5 =>', round(4.5))
# 0.5 => 0
# 1.5 => 2
# 2.5 => 2
# 3.5 => 4
# 4.5 => 4

ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਇੱਕ ਸਮ ਸੰਖਿਆ ਨੂੰ ਗੋਲ ਕਰਨ ਦੀ ਪਰਿਭਾਸ਼ਾ ਦੋ ਦਸ਼ਮਲਵ ਸਥਾਨਾਂ ਤੋਂ ਬਾਅਦ ਪ੍ਰੋਸੈਸਿੰਗ ‘ਤੇ ਵੀ ਲਾਗੂ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

ਇਹ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਹੈ ਕਿ ਦਸ਼ਮਲਵ ਨੂੰ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਸੰਖਿਆਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਬਿਲਕੁਲ ਨਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ।

ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰਾਂ ਲਈ ਗੋਲ() ਦਾ ਵਿਵਹਾਰ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਕਰ ਸਕਦਾ ਹੈ:ਉਦਾਹਰਨ ਲਈ, ਰਾਊਂਡ(2.675, 2) ਤੁਹਾਨੂੰ ਉਮੀਦ ਮੁਤਾਬਕ 2.68 ਦੀ ਬਜਾਏ 2.67 ਦੇਵੇਗਾ। ਇਹ ਕੋਈ ਬੱਗ ਨਹੀਂ ਹੈ।:ਇਹ ਇਸ ਤੱਥ ਦਾ ਨਤੀਜਾ ਹੈ ਕਿ ਜ਼ਿਆਦਾਤਰ ਦਸ਼ਮਲਵ ਨੂੰ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰਾਂ ਦੁਆਰਾ ਬਿਲਕੁਲ ਨਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
round() — Built-in Functions — Python 3.10.2 Documentation

ਜੇਕਰ ਤੁਸੀਂ ਦਸ਼ਮਲਵ ਸੰਖਿਆਵਾਂ ਦੀ ਆਮ ਰਾਊਂਡਿੰਗ ਜਾਂ ਸਟੀਕ ਰਾਊਂਡਿੰਗ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦਸ਼ਮਲਵ ਮਾਤਰਾ (ਹੇਠਾਂ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ) ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹ ਵੀ ਨੋਟ ਕਰੋ ਕਿ ਪਾਈਥਨ 2 ਵਿੱਚ round() ਇੱਕ ਬਰਾਬਰ ਸੰਖਿਆ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਪਰ ਰਾਉਂਡਿੰਗ ਹੈ।

ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦਸ਼ਮਲਵ ਦੀ quantize()

ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਦਸ਼ਮਲਵ ਮੋਡੀਊਲ ਨੂੰ ਸਹੀ ਦਸ਼ਮਲਵ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਦਸ਼ਮਲਵ ਮੋਡੀਊਲ ਦੀ quantize() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਰਾਊਂਡਿੰਗ ਮੋਡ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਕੇ ਸੰਖਿਆਵਾਂ ਨੂੰ ਗੋਲ ਕਰਨਾ ਸੰਭਵ ਹੈ।

quantize() ਵਿਧੀ ਦੇ ਆਰਗੂਮੈਂਟ ਰਾਊਂਡਿੰਗ ਲਈ ਸੈੱਟ ਮੁੱਲਾਂ ਦੇ ਕ੍ਰਮਵਾਰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਰਥ ਹਨ।

  • ROUND_HALF_UP:ਆਮ ਰਾਊਂਡਿੰਗ
  • ROUND_HALF_EVEN:ਸਮ ਸੰਖਿਆਵਾਂ ਲਈ ਪੂਰਨ ਅੰਕ

ਦਸ਼ਮਲਵ ਮੋਡੀਊਲ ਇੱਕ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਇਸਲਈ ਕੋਈ ਵਾਧੂ ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਪਰ ਆਯਾਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

ਇੱਕ ਦਸ਼ਮਲਵ ਵਸਤੂ ਬਣਾਉਣਾ

ਦਸ਼ਮਲਵ () ਦਸ਼ਮਲਵ ਕਿਸਮ ਦੇ ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਫਲੋਟ ਕਿਸਮ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਮੁੱਲ ਨੂੰ ਅਸਲ ਵਿੱਚ ਕੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

print(type(Decimal(0.05)))
# <class 'decimal.Decimal'>

ਜਿਵੇਂ ਕਿ ਉਦਾਹਰਨ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, 0.05 ਨੂੰ ਬਿਲਕੁਲ 0.05 ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਉੱਪਰ ਦੱਸੇ ਗਏ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ round() ਨੂੰ ਉਦਾਹਰਨ ਵਿੱਚ 0.05 ਸਮੇਤ ਦਸ਼ਮਲਵ ਮੁੱਲਾਂ ਲਈ ਉਮੀਦ ਨਾਲੋਂ ਵੱਖਰੇ ਮੁੱਲ ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਗਿਆ ਹੈ।

ਕਿਉਂਕਿ 0.5 ਇੱਕ-ਅੱਧਾ ਹੈ (2 ਦੀ -1 ਪਾਵਰ), ਇਸ ਨੂੰ ਬਾਈਨਰੀ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਬਿਲਕੁਲ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

print(Decimal(0.5))
# 0.5

ਜੇਕਰ ਤੁਸੀਂ ਫਲੋਟ ਕਿਸਮ ਦੀ ਬਜਾਏ ਸਟ੍ਰਿੰਗ ਕਿਸਮ str ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਸ ਨੂੰ ਸਹੀ ਮੁੱਲ ਦੀ ਦਸ਼ਮਲਵ ਕਿਸਮ ਮੰਨਿਆ ਜਾਵੇਗਾ।

print(Decimal('0.05'))
# 0.05

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਦਾ ਗੋਲਾਕਾਰ ਅਤੇ ਸਮ ਸੰਖਿਆਵਾਂ ਲਈ ਪੂਰਨ ਅੰਕ

ਮੁੱਲ ਨੂੰ ਗੋਲ ਕਰਨ ਲਈ ਦਸ਼ਮਲਵ ਕਿਸਮ ਦੀ ਵਸਤੂ ਤੋਂ quantize() ਨੂੰ ਕਾਲ ਕਰੋ।

quantize() ਦਾ ਪਹਿਲਾ ਆਰਗੂਮੈਂਟ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਜਿਸ ਵਿੱਚ ਅੰਕਾਂ ਦੀ ਉਹੀ ਸੰਖਿਆ ਹੁੰਦੀ ਹੈ ਜਿੰਨੇ ਅੰਕ ਤੁਸੀਂ ਲੱਭਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ‘0.1’ ਜਾਂ ‘0.01’।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਆਰਗੂਮੈਂਟ ROUNDING ਰਾਊਂਡਿੰਗ ਮੋਡ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ; ਜੇਕਰ ROUND_HALF_UP ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਆਮ ਰਾਊਂਡਿੰਗ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।

f = 123.456

print(Decimal(str(f)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 123

print(Decimal(str(f)).quantize(Decimal('0.1'), rounding=ROUND_HALF_UP))
# 123.5

print(Decimal(str(f)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 123.46

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਰਾਉਂਡ() ਦੇ ਉਲਟ, 0.5 ਨੂੰ 1 ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

print('0.4 =>', Decimal(str(0.4)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.5 =>', Decimal(str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
print('0.6 =>', Decimal(str(0.6)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
# 0.4 => 0
# 0.5 => 1
# 0.6 => 1

ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਰਾਊਂਡਿੰਗ ROUND_HALF_EVEN ‘ਤੇ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਰਾਊਂਡਿੰਗ ਨੂੰ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ round() ਦੀ ਤਰ੍ਹਾਂ ਬਰਾਬਰ ਸੰਖਿਆਵਾਂ ‘ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਜੇਕਰ ਇੱਕ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਫਲੋਟ ਕਿਸਮ ਨੂੰ ਦਸ਼ਮਲਵ() ਦੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਫਲੋਟ ਕਿਸਮ ਦੇ ਅਸਲ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਮੁੱਲ ਦੇ ਨਾਲ ਦਸ਼ਮਲਵ ਵਸਤੂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਕੁਆਂਟਾਈਜ਼ () ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਨਤੀਜਾ ਵਿਧੀ ਜੋ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਉਸ ਤੋਂ ਵੱਖਰੀ ਹੋਵੇਗੀ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ round() ਵਾਂਗ।

print('0.05 =>', round(0.05, 1))
print('0.15 =>', round(0.15, 1))
print('0.25 =>', round(0.25, 1))
print('0.35 =>', round(0.35, 1))
print('0.45 =>', round(0.45, 1))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

print('0.05 =>', Decimal(0.05).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(0.15).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(0.25).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(0.35).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(0.45).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.1
# 0.15 => 0.1
# 0.25 => 0.2
# 0.35 => 0.3
# 0.45 => 0.5

ਜੇਕਰ ਦਸ਼ਮਲਵ() ਦੀ ਆਰਗੂਮੈਂਟ ਨੂੰ str ਕਿਸਮ ਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਬਿਲਕੁਲ ਉਸੇ ਮੁੱਲ ਦੀ ਦਸ਼ਮਲਵ ਵਸਤੂ ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਨਤੀਜਾ ਉਮੀਦ ਅਨੁਸਾਰ ਹੁੰਦਾ ਹੈ।

print('0.05 =>', Decimal(str(0.05)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.15 =>', Decimal(str(0.15)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.25 =>', Decimal(str(0.25)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.35 =>', Decimal(str(0.35)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
print('0.45 =>', Decimal(str(0.45)).quantize(Decimal('0.1'), rounding=ROUND_HALF_EVEN))
# 0.05 => 0.0
# 0.15 => 0.2
# 0.25 => 0.2
# 0.35 => 0.4
# 0.45 => 0.4

ਕਿਉਂਕਿ 0.5 ਨੂੰ ਫਲੋਟ ਕਿਸਮ ਦੁਆਰਾ ਸਹੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਫਲੋਟ ਕਿਸਮ ਨੂੰ ਦਸ਼ਮਲਵ () ਦੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਜਦੋਂ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਦਸ਼ਮਲਵ ਸਥਾਨ ‘ਤੇ ਰਾਉਂਡਿੰਗ ਕਰਨ ਵੇਲੇ ਸਤਰ str ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੁਰੱਖਿਅਤ ਹੁੰਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, 2.675 ਅਸਲ ਵਿੱਚ 2.67499 ਹੈ…. ਫਲੋਟ ਕਿਸਮ ਵਿੱਚ। ਇਸਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਦੋ ਦਸ਼ਮਲਵ ਸਥਾਨਾਂ ‘ਤੇ ਗੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਦਸ਼ਮਲਵ() ਲਈ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨਿਰਧਾਰਤ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਨਤੀਜਾ ਅਨੁਮਾਨਿਤ ਨਤੀਜੇ ਤੋਂ ਵੱਖਰਾ ਹੋਵੇਗਾ ਭਾਵੇਂ ਤੁਸੀਂ ਨਜ਼ਦੀਕੀ ਸੰਪੂਰਨ ਸੰਖਿਆ (ROUND_HALF_UP) ਜਾਂ ਇੱਕ ਬਰਾਬਰ ਸੰਖਿਆ (ROUND_HALF_EVEN) ਵਿੱਚ ਗੋਲ ਕਰੋ। ).

print(Decimal(2.675))
# 2.67499999999999982236431605997495353221893310546875

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
# 2.68

print(Decimal(2.675).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.67

print(Decimal(str(2.675)).quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN))
# 2.68

ਨੋਟ ਕਰੋ ਕਿ quantize() ਵਿਧੀ ਦਸ਼ਮਲਵ ਕਿਸਮ ਦਾ ਨੰਬਰ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਫਲੋਟ ਕਿਸਮ ਨੰਬਰ ‘ਤੇ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਸਨੂੰ float() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਫਲੋਟ ਕਿਸਮ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ, ਨਹੀਂ ਤਾਂ ਇੱਕ ਗਲਤੀ ਆਵੇਗੀ।

d = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

print(d)
# 123.46

print(type(d))
# <class 'decimal.Decimal'>

# print(1.2 + d)
# TypeError: unsupported operand type(s) for +: 'float' and 'decimal.Decimal'

print(1.2 + float(d))
# 124.66

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਗੋਲਾਕਾਰ ਅਤੇ ਸਮ ਸੰਖਿਆਵਾਂ ਦਾ ਪੂਰਨ ਅੰਕ

ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਪੂਰਨ ਅੰਕ ‘ਤੇ ਗੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ’10’ ਵਰਗੀ ਕੋਈ ਚੀਜ਼ ਨਿਰਧਾਰਤ ਕਰਨ ਨਾਲ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦਾ ਨਤੀਜਾ ਨਹੀਂ ਮਿਲੇਗਾ।

i = 99518

print(Decimal(i).quantize(Decimal('10'), rounding=ROUND_HALF_UP))
# 99518

ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ quantize() ਦਸ਼ਮਲਵ ਵਸਤੂ ਦੇ ਘਾਤ ਅੰਕ ਦੇ ਅਨੁਸਾਰ ਰਾਊਂਡਿੰਗ ਕਰਦਾ ਹੈ, ਪਰ ਦਸ਼ਮਲਵ (’10’) ਦਾ ਘਾਤਕ 0 ਹੈ, 1 ਨਹੀਂ।

ਤੁਸੀਂ ਇੱਕ ਘਾਤਕ ਸਤਰ (ਉਦਾਹਰਨ ਲਈ, ‘1E1’) ਵਜੋਂ E ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਆਰਬਿਟਰਰੀ ਐਕਸਪੋਨੈਂਟ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਐਕਸਪੋਨੈਂਟ ਐਕਸਪੋਨੈਂਟ ਨੂੰ as_tuple ਵਿਧੀ ਵਿੱਚ ਚੈੱਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

print(Decimal('10').as_tuple())
# DecimalTuple(sign=0, digits=(1, 0), exponent=0)

print(Decimal('1E1').as_tuple())
# DecimalTuple(sign=0, digits=(1,), exponent=1)

ਜਿਵੇਂ ਕਿ ਇਹ ਹੈ, ਨਤੀਜਾ E ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਘਾਤਕ ਸੰਕੇਤਾਂ ਵਿੱਚ ਹੋਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ ਸਾਧਾਰਨ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਾਂ ਜੇਕਰ ਤੁਸੀਂ ਰਾਊਂਡਿੰਗ ਤੋਂ ਬਾਅਦ ਪੂਰਨ ਅੰਕ ਇੰਟ ਟਾਈਪ ਨਾਲ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਨਤੀਜਾ ਬਦਲਣ ਲਈ int() ਦੀ ਵਰਤੋਂ ਕਰੋ।

print(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP))
# 9.952E+4

print(int(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 99520

print(int(Decimal(i).quantize(Decimal('1E2'), rounding=ROUND_HALF_UP)))
# 99500

print(int(Decimal(i).quantize(Decimal('1E3'), rounding=ROUND_HALF_UP)))
# 100000

ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਰਾਊਂਡਿੰਗ ROUND_HALF_UP ‘ਤੇ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਆਮ ਰਾਊਂਡਿੰਗ ਹੋਵੇਗੀ, ਉਦਾਹਰਨ ਲਈ, 5 ਨੂੰ 10 ‘ਤੇ ਗੋਲ ਕੀਤਾ ਜਾਵੇਗਾ।

print('4 =>', int(Decimal(4).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('5 =>', int(Decimal(5).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
print('6 =>', int(Decimal(6).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 4 => 0
# 5 => 10
# 6 => 10

ਬੇਸ਼ੱਕ, ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ.

ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ

ਦਸ਼ਮਲਵ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਤਰੀਕਾ ਸਹੀ ਅਤੇ ਸੁਰੱਖਿਅਤ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਕਿਸਮ ਦੇ ਰੂਪਾਂਤਰਣ ਨਾਲ ਅਰਾਮਦੇਹ ਨਹੀਂ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਮ ਰਾਊਂਡਿੰਗ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ।

ਅਜਿਹਾ ਕਰਨ ਦੇ ਕਈ ਸੰਭਵ ਤਰੀਕੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਫੰਕਸ਼ਨ।

def my_round(val, digit=0):
    p = 10 ** digit
    return (val * p * 2 + 1) // 2 / p

ਜੇਕਰ ਤੁਹਾਨੂੰ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਨਿਰਧਾਰਤ ਕਰਨ ਅਤੇ ਹਮੇਸ਼ਾ ਪਹਿਲੇ ਦਸ਼ਮਲਵ ਸਥਾਨ ‘ਤੇ ਗੋਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਸਧਾਰਨ ਫਾਰਮ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

my_round_int = lambda x: int((x * 2 + 1) // 2)

ਜੇਕਰ ਤੁਹਾਨੂੰ ਸਟੀਕ ਹੋਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਦਸ਼ਮਲਵ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵਧੇਰੇ ਸੁਰੱਖਿਅਤ ਹੈ।

ਨਿਮਨਲਿਖਤ ਸਿਰਫ ਸੰਦਰਭ ਲਈ ਹੈ।

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਦਸ਼ਮਲਵ ਨੂੰ ਗੋਲ ਕਰੋ।

print(int(my_round(f)))
# 123

print(my_round_int(f))
# 123

print(my_round(f, 1))
# 123.5

print(my_round(f, 2))
# 123.46

ਰਾਉਂਡ ਦੇ ਉਲਟ, ਆਮ ਰਾਊਂਡਿੰਗ ਦੇ ਅਨੁਸਾਰ 0.5 1 ਬਣ ਜਾਂਦਾ ਹੈ।

print(int(my_round(0.4)))
print(int(my_round(0.5)))
print(int(my_round(0.6)))
# 0
# 1
# 1

ਅੰਕਾਂ ਦੀ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਲਈ ਗੋਲ ਪੂਰਨ ਅੰਕ

i = 99518

print(int(my_round(i, -1)))
# 99520

print(int(my_round(i, -2)))
# 99500

print(int(my_round(i, -3)))
# 100000

ਰਾਉਂਡ ਦੇ ਉਲਟ, ਆਮ ਰਾਊਂਡਿੰਗ ਦੇ ਅਨੁਸਾਰ 5 10 ਬਣ ਜਾਂਦਾ ਹੈ।

print(int(my_round(4, -1)))
print(int(my_round(5, -1)))
print(int(my_round(6, -1)))
# 0
# 10
# 10

ਨੋਟ: ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਲਈ

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਫੰਕਸ਼ਨ ਵਿੱਚ, -0.5 ਨੂੰ 0 ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਗਿਆ ਹੈ।

print(int(my_round(-0.4)))
print(int(my_round(-0.5)))
print(int(my_round(-0.6)))
# 0
# 0
# -1

ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਲਈ ਰਾਊਂਡਿੰਗ ਬਾਰੇ ਸੋਚਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ -0.5 ਨੂੰ -1 ਵਿੱਚ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਸੋਧ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ

import math

def my_round2(val, digit=0):
    p = 10 ** digit
    s = math.copysign(1, val)
    return (s * val * p * 2 + 1) // 2 / p * s

print(int(my_round2(-0.4)))
print(int(my_round2(-0.5)))
print(int(my_round2(-0.6)))
# 0
# -1
# -1
Copied title and URL