ਪਾਈਥਨ ਵਿੱਚ ਫਾਰਮੈਟ ਰੂਪਾਂਤਰਨ, ਫਾਰਮੈਟ (ਜ਼ੀਰੋ-ਫਿਲਿੰਗ, ਘਾਤਕ ਸੰਕੇਤ, ਹੈਕਸਾਡੈਸੀਮਲ, ਆਦਿ)

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਨੰਬਰ ਜਾਂ ਸਟ੍ਰਿੰਗ ਨੂੰ ਵੱਖ-ਵੱਖ ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਬਦਲਣ (ਫਾਰਮੈਟ) ਕਰਨ ਲਈ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਫਾਰਮੈਟ() ਜਾਂ ਸਤਰ ਵਿਧੀ str.format() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਦੱਸਾਂਗੇ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ।

• ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ)format()
• ਸਤਰ ਢੰਗstr.format()

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹੇਠਾਂ ਦਿੱਤੇ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਫਾਰਮੈਟ ਨਿਰਧਾਰਨ ਸਤਰ ਨੂੰ ਨਮੂਨਾ ਕੋਡ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

• ਖੱਬੇ-ਜਾਇਜ਼, ਕੇਂਦਰ-ਜਾਇਜ਼, ਸੱਜਾ-ਜਾਇਜ਼
• ਜ਼ੀਰੋ ਭਰੋ
• ਚਿੰਨ੍ਹ (ਪਲੱਸ ਜਾਂ ਘਟਾਓ)
• ਅੰਕ ਵਿਭਾਜਕ (ਕਾਮਾ, ਅੰਡਰਸਕੋਰ)
• ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰ
• ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਦਿਓ
• ਮਹੱਤਵਪੂਰਨ ਅੰਕੜੇ (ਮਹੱਤਵਪੂਰਣ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ)
• ਘਾਤਕ ਸੰਕੇਤ
• ਪ੍ਰਤੀਸ਼ਤ ਡਿਸਪਲੇ

ਨੋਟ ਕਰੋ ਕਿ ਪਾਈਥਨ 3.6 ਤੋਂ, ਇਸ ਨੂੰ ਹੋਰ ਸੰਖੇਪ ਬਣਾਉਣ ਲਈ ਸਟ੍ਰਿੰਗ ਵਿਧੀ str.format() ਵਿੱਚ f-strings (f-strings) ਨੂੰ ਜੋੜਿਆ ਗਿਆ ਹੈ।

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ: ਫਾਰਮੈਟ ()

format() ਇੱਕ ਸਟੈਂਡਰਡ ਪਾਈਥਨ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ।

• Built-in Functions — format() — Python 3.10.0 Documentation

ਰੂਪਰੇਖਾ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ।

• format(value, format_spec)
  • ਪਹਿਲੀ ਦਲੀਲ: thevalue
    ਮੂਲ ਮੁੱਲ। ਸਟ੍ਰਿੰਗ ਸਟ੍ਰਿੰਗ, ਨੰਬਰ ਇੰਟ, ਫਲੋਟ, ਆਦਿ।
  • ਦੂਜੀ ਦਲੀਲformat_spec
    ਫਾਰਮੈਟ ਨਿਰਧਾਰਨ ਸਤਰ। ਸਤਰ str
  • ਵਾਪਸੀ ਮੁੱਲ: ਇੱਕ ਫਾਰਮੈਟ ਕੀਤੀ ਸਤਰ str

ਉਦਾਹਰਨਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ। ਫਾਰਮੈਟ ਸਤਰ ਦੀਆਂ ਕਿਸਮਾਂ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ, ਇਸ ਬਾਰੇ ਬਾਅਦ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ।

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

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

ਸਤਰ ਵਿਧੀ str.format()

ਸਤਰ str ਕਿਸਮ ਲਈ ਇੱਕ ਫਾਰਮੈਟ() ਵਿਧੀ ਵੀ ਹੈ।

• Built-in Types — str.format() — Python 3.10.0 Documentation

ਸਤਰ ਵਿੱਚ {} ਜੋ ਕਿ ਫਾਰਮੈਟ() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਨੂੰ ਸਬਸਟੀਟਿਊਸ਼ਨ ਫੀਲਡ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਾਰਮੈਟ() ਵਿਧੀ ਦੇ ਆਰਗੂਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।

ਫਾਰਮੈਟ ਨਿਰਧਾਰਨ ਸਤਰ ਨੂੰ “:” ਦੇ ਬਾਅਦ ਬਦਲਵੇਂ ਖੇਤਰ {} ਵਿੱਚ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਵਾਪਸੀ ਮੁੱਲ ਇੱਕ ਫਾਰਮੈਟ ਕੀਤੀ ਸਟ੍ਰਿੰਗ ਸਟ੍ਰਿੰਗ ਹੈ।

ਉੱਪਰ ਦੱਸੇ ਗਏ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਫਾਰਮੈਟ () ਦੇ ਬਰਾਬਰ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ।

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

ਦੁਬਾਰਾ ਫਿਰ, ਅਸੀਂ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਅੰਕੀ ਲਿਟਰਲ ਅਤੇ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਪਰ ਬੇਸ਼ੱਕ ਵੇਰੀਏਬਲ ਵੀ ਸਵੀਕਾਰਯੋਗ ਹਨ।

ਬਦਲਵੇਂ ਖੇਤਰਾਂ ਲਈ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨਾ

ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਦਿਓ (ਡਿਫੌਲਟ)

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

ਇੱਕ ਸਤਰ ਵਿੱਚ ਵੇਰੀਏਬਲ ਮੁੱਲਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਛਾਪਣ ਲਈ ਉਪਯੋਗੀ।

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

ਪੂਰਨ ਅੰਕ ਮੁੱਲਾਂ ਲਈ ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟ ਦਿਓ

ਜੇਕਰ ਇੱਕ ਪੂਰਨ ਅੰਕ ਮੁੱਲ {} ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਜਿਵੇਂ ਕਿ {0} ਜਾਂ {1}, ਆਉਟਪੁੱਟ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਕ੍ਰਮ ‘ਤੇ ਨਿਰਭਰ ਕਰੇਗੀ। ਇੱਕੋ ਨੰਬਰ ਨੂੰ ਵਾਰ-ਵਾਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਉਦੋਂ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਸਤਰ ਵਿੱਚ ਉਹੀ ਮੁੱਲ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ।

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

ਆਰਬਿਟਰੇਰੀ ਨਾਮਾਂ (ਸਟਰਿੰਗਾਂ) ਲਈ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਸ ਦਿਓ

ਤੁਸੀਂ {} ਵਿੱਚ ਕੋਈ ਵੀ ਨਾਮ ਵੀ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਰਜ ਕਰ ਸਕਦੇ ਹੋ।

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਇੱਕ ਸੂਚੀ ਜਾਂ ਸ਼ਬਦਕੋਸ਼ ਦਿਓ

ਸੂਚੀਆਂ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਨੂੰ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇੱਕ ਵਿਕਲਪ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਦੇ ਸੂਚਕਾਂਕ ਜਾਂ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੀ ਕੁੰਜੀ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ [] ਦੀ ਵਰਤੋਂ ਕਰੋ। ਨੋਟ ਕਰੋ ਕਿ ਕੋਟੇਸ਼ਨ ਚਿੰਨ੍ਹ “‘” ਅਤੇ “” ਸ਼ਬਦਕੋਸ਼ ਕੁੰਜੀਆਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਨਹੀਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

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

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

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

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

ਕਰਲੀ ਬਰੈਕਟਾਂ ਦਾ ਵਰਣਨ {}

ਜੇਕਰ ਤੁਸੀਂ ਕਰਲੀ ਬਰੈਕਟ {,} ਨੂੰ ਫਾਰਮੈਟ() ਵਿਧੀ ਵਿੱਚ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ {{,}} ਵਾਂਗ ਦੋ ਵਾਰ ਦੁਹਰਾਓ। ਨੋਟ ਕਰੋ ਕਿ ਬੈਕਸਲੈਸ਼ਾਂ ਤੋਂ ਬਚਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

ਫਾਰਮੈਟ ਕੀਤੀ ਸਤਰ

ਦੋਵਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਫਾਰਮੈਟ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ, {} ਵਿੱਚ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਜਾਂ ਨਾਮ ਸਤਰ ਦੇ ਬਾਅਦ “:ਫਾਰਮੈਟ ਸਤਰ” ਲਿਖੋ।

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

ਹੇਠਾਂ, ਅਸੀਂ ਸਮਝਾਵਾਂਗੇ ਕਿ ਫਾਰਮੈਟ ਸਟ੍ਰਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਰਮੈਟ ਨੂੰ ਕਿਵੇਂ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਹੈ। ਨਮੂਨਾ ਕੋਡ ਸਟ੍ਰਿੰਗ ਵਿਧੀ str.format() ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਪਰ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਫਾਰਮੈਟ() ਨਾਲ ਉਹੀ ਫਾਰਮੈਟ ਸਟ੍ਰਿੰਗ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਫਾਰਮੈਟ () ਵਿੱਚ, ਫਾਰਮੈਟ ਨਿਰਧਾਰਨ ਸਤਰ ਨੂੰ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਖੱਬੇ-ਜਾਇਜ਼, ਕੇਂਦਰ-ਜਾਇਜ਼, ਸੱਜਾ-ਜਾਇਜ਼

ਤੁਸੀਂ ਹੇਠਾਂ ਖੱਬੇ-ਉਚਿਤ, ਕੇਂਦਰ-ਉਚਿਤ, ਸੱਜੇ-ਉਚਿਤ, ਆਦਿ ਨੂੰ ਇਕਸਾਰ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ ਸੰਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ।

• <
• ^
• >

print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

ਤੁਸੀਂ ਭਰੇ ਜਾਣ ਲਈ ਇੱਕ ਅੱਖਰ ਵੀ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਛੱਡਿਆ ਗਿਆ ਹੈ, ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਇਹ ਇੱਕ ਸਪੇਸ ਹੈ।

ਤੁਸੀਂ ਡਬਲ-ਬਾਈਟ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਦੋਂ ਤੱਕ ਇਹ ਸਿੰਗਲ ਅੱਖਰ ਹੈ।

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

> ਦੇ ਨਾਲ ਸਹੀ-ਉਚਿਤਤਾ; ਚਿੰਨ੍ਹ (-,+) ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਰੱਖਦਾ। ਜੇਕਰ ਤੁਸੀਂ = ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਚਿੰਨ੍ਹ ਨਿਰਧਾਰਤ ਅੱਖਰ ਦੇ ਬਾਅਦ ਆਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ + ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ + ਬਾਅਦ = ਲਿਖੋ। ਸਾਈਨ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਵੇਰਵੇ ਬਾਅਦ ਵਿੱਚ ਦੱਸੇ ਗਏ ਹਨ.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^, ਅਤੇ > ਸਤਰ ਲਈ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ = ਇੱਕ ਗਲਤੀ ValueError ਵਿੱਚ ਨਤੀਜਾ ਹੋਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ = ਇੱਕ ਸਤਰ ਲਈ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ int() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ।

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

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

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

ਸੂਚੀਆਂ, ਟੂਪਲਾਂ, ਆਦਿ ਇੱਕ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀਆਂ ਹਨ ਜੇਕਰ ਇਸ ਤਰ੍ਹਾਂ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ str() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

ਖੱਬੇ-ਉਚਿਤ, ਕੇਂਦਰ-ਉਚਿਤ, ਅਤੇ ਸੱਜੇ-ਉਚਿਤ ਲਈ, ljust(), center(), ਅਤੇ rjust() ਨਾਮਕ ਸਮਰਪਿਤ ਸਟ੍ਰਿੰਗ ਵਿਧੀਆਂ ਵੀ ਹਨ।

0 ਭਰੋ

ਜੇਕਰ ਤੁਸੀਂ ਜ਼ੀਰੋ-ਫਿਲਿੰਗ ਦੁਆਰਾ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਅੱਖਰ ਨੂੰ 0 ‘ਤੇ ਭਰਨ ਲਈ ਸੈੱਟ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਸਹੀ-ਸਹੀ ਠਹਿਰਾਓ।

ਜ਼ੀਰੋ-ਫਿਲਿੰਗ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਜੇਕਰ ਅਲਾਈਨਮੈਂਟ ਚਿੰਨ੍ਹ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ = ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਸੀ।

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

#ਗਲਤੀ!

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

ਜ਼ੀਰੋ-ਫਿਲਿੰਗ ਲਈ, zfill() ਨਾਮਕ ਇੱਕ ਸਮਰਪਿਤ ਸਤਰ ਵਿਧੀ ਵੀ ਹੈ।

ਚਿੰਨ੍ਹ (ਪਲੱਸ ਜਾਂ ਘਟਾਓ)

ਮੂਲ ਰੂਪ ਵਿੱਚ, ਸਿਰਫ਼ ਰਿਣਾਤਮਕ ਸੰਖਿਆਵਾਂ ਨੂੰ ਇੱਕ ਚਿੰਨ੍ਹ (ਘਟਾਓ-) ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

ਮਨਮਾਨੇ ਅੱਖਰਾਂ ਨਾਲ ਭਰਨ ਵੇਲੇ ਸਾਵਧਾਨ ਰਹੋ, ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸੇ ਗਏ ਜ਼ੀਰੋ-ਫਿਲਿੰਗ। ਪੂਰਵ-ਨਿਰਧਾਰਤ, ਬਿਨਾਂ + ਅਤੇ ਬਿਨਾਂ ਸਪੇਸ, ਇੱਕ ਹੋਰ ਅੱਖਰ ਨਾਲ ਸਕਾਰਾਤਮਕ ਸੰਖਿਆਵਾਂ ਨੂੰ ਭਰਦਾ ਹੈ।

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

ਜੇਕਰ ਇੱਕ ਅਲਾਈਨਮੈਂਟ ਪ੍ਰਤੀਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅਲਾਈਨਮੈਂਟ ਚਿੰਨ੍ਹ ਦੇ ਬਾਅਦ ਚਿੰਨ੍ਹ ਅਹੁਦਾ ਚਿੰਨ੍ਹ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

ਅੰਕ ਵਿਭਾਜਕ (ਕਾਮਾ, ਅੰਡਰਸਕੋਰ)

ਹਰ ਤਿੰਨ ਅੰਕਾਂ ਵਿੱਚ ਇੱਕ ਕੌਮਾ ਜਾਂ ਅੰਡਰਸਕੋਰ _ ਵੱਖਰਾ ਜੋੜੋ। ਇਹ ਵੱਡੀ ਗਿਣਤੀ ਨੂੰ ਪੜ੍ਹਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਅੰਡਰਸਕੋਰ_ ਪਾਈਥਨ 3.6 ਵਿੱਚ ਇੱਕ ਵਿਕਲਪ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸਲਈ ਇਸਨੂੰ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

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

print('{:,}'.format(1234.56789))
# 1,234.56789

ਬਾਈਨਰੀ, ਅਸ਼ਟਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰ

ਆਉਟਪੁੱਟ ਲਈ ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ ਨੂੰ ਬਾਈਨਰੀ, ਅਸ਼ਟਾਲ, ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

• b: ਬਾਈਨਰੀ
• o: ਅਸ਼ਟਾਲ
• d: ਦਸ਼ਮਲਵ
• x,X: ਹੈਕਸਾਡੈਸੀਮਲ (ਵੱਡੇ ਅੱਖਰ ਵੱਡੇ ਅੱਖਰ ਹਨ)

print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

ਇਸਨੂੰ 0-ਫਿਲ ਨਾਲ ਵੀ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਅਕਸਰ ਬਾਈਨਰੀ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਅੰਕਾਂ ਨੂੰ ਇਕਸਾਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

ਨੋਟ ਕਰੋ ਕਿ ਜ਼ੀਰੋ-ਫਿਲ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਅਗੇਤਰ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

ਬਾਈਨਰੀ ਅਤੇ ਹੈਕਸਾਡੈਸੀਮਲ ਸੰਖਿਆਵਾਂ ਲਈ, ਸਿਰਫ਼ ਅੰਡਰਸਕੋਰ _ ਅੰਕਾਂ ਦਾ ਵਿਭਾਜਕ ਹੀ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ (ਪਾਈਥਨ 3.6 ਜਾਂ ਬਾਅਦ ਵਾਲਾ)। 4-ਅੰਕ ਵਿਭਾਜਕ ਵਰਤਿਆ ਗਿਆ ਹੈ; ਜ਼ੀਰੋ-ਭਰੇ ਅੱਖਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਅੰਡਰਸਕੋਰ ਦੀ ਸੰਖਿਆ ਨੂੰ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

ਸਿਰਫ਼ ਪੂਰਨ ਅੰਕ ਕਿਸਮ int ਹੀ ਫਾਰਮੈਟ ਨੂੰ ਬਾਈਨਰੀ ਜਾਂ ਹੈਕਸਾਡੈਸੀਮਲ ਵਿੱਚ ਬਦਲ ਸਕਦੀ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣ ਲਈ int() ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਦਿਓ

ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰੋ: n ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਅੰਕਾਂ ਦੀ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਬਣ ਜਾਂਦੀ ਹੈ ਭਾਵੇਂ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

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

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

ਜੇਕਰ ਤੁਸੀਂ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਅਸਲ ਸੰਖਿਆ ਤੋਂ ਘੱਟ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੰਖਿਆ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਮੁੱਲ ਗੋਲ ਹੋ ਜਾਵੇਗਾ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਪੂਰਨ ਸੰਖਿਆ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਸਮ ਸੰਖਿਆ, ਉਦਾਹਰਨ ਲਈ. 0.5 ਨੂੰ 0 ਵਿੱਚ ਗੋਲ ਕੀਤਾ ਗਿਆ ਹੈ।

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

ਜੇਕਰ ਤੁਸੀਂ ਜਨਰਲ ਰਾਊਂਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦਸ਼ਮਲਵ ਦੀ quantize() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਘਾਤਕ ਸੰਕੇਤ

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

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

ਜੇਕਰ ਤੁਸੀਂ ਫਾਰਮੈਟਿੰਗ ਨਿਰਧਾਰਨ ਸਤਰ ਵਿੱਚ e ਜਾਂ E ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਘਾਤਕ ਸੰਕੇਤ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ। ਆਉਟਪੁੱਟ ਵਿੱਚ ਵਰਤੇ ਗਏ ਅੱਖਰ ਕ੍ਰਮਵਾਰ e ਅਤੇ E ਹੋਣਗੇ।

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। ਪੂਰਨ ਅੰਕ ਹਮੇਸ਼ਾ ਇੱਕ ਅੰਕ ਦਾ ਹੋਵੇਗਾ ਅਤੇ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਅੰਕਾਂ ਦੀ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਹੋਵੇਗੀ।

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

ਨੋਟ ਕਰੋ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਖੱਬਾ-ਉਚਿਤ, ਕੇਂਦਰ-ਉਚਿਤ, ਸੱਜਾ-ਉਚਿਤ, ਜਾਂ ਜ਼ੀਰੋ-ਭਰਿਆ, e-, E+, ਆਦਿ ਨੂੰ ਵੀ ਅੰਕਾਂ (ਅੱਖਰ) ਵਜੋਂ ਗਿਣਿਆ ਜਾਵੇਗਾ।

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

ਮਹੱਤਵਪੂਰਨ ਅੰਕੜੇ (ਮਹੱਤਵਪੂਰਣ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ)

ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰਕੇ ਅੰਕਾਂ ਦੀ ਸਮੁੱਚੀ ਸੰਖਿਆ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਨਤੀਜੇ ‘ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਘਾਤਕ ਸੰਕੇਤ ਆਪਣੇ ਆਪ ਹੀ ਵਰਤੇ ਜਾਣਗੇ। ਨੋਟ ਕਰੋ ਕਿ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਦੇ ਜ਼ੀਰੋ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇਗਾ।
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

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

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

ਜੇਕਰ ਅਸੀਂ ਉਸੇ ਮੁੱਲ ‘ਤੇ ਕਾਰਵਾਈ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਕ੍ਰਮਵਾਰ ਹੇਠ ਲਿਖਿਆਂ ਮਿਲਦਾ ਹੈ।

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

g ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਜਾਂ ਜੇਕਰ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਦੇ ਜ਼ੀਰੋ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਜੇਕਰ ਤੁਸੀਂ ਮਹੱਤਵਪੂਰਨ ਅੰਕੜਿਆਂ (ਮਹੱਤਵਪੂਰਣ ਅੰਕਾਂ ਦੀ ਸੰਖਿਆ) ਦੀ ਇੱਕੋ ਜਿਹੀ ਸੰਖਿਆ ਨੂੰ ਆਊਟਪੁੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ e ਜਾਂ E ਦੇ ਘਾਤਕ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਪੂਰਨ ਅੰਕ ਹਮੇਸ਼ਾ ਇੱਕ ਅੰਕ ਹੁੰਦਾ ਹੈ ਅਤੇ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਅੰਕਾਂ ਦੀ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ n ਮਹੱਤਵਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਿਰਫ਼ n-1 ਦਿਓ।

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

ਪ੍ਰਤੀਸ਼ਤ ਡਿਸਪਲੇ

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

ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। ਡਿਫੌਲਟ ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ਛੇ ਅੰਕਾਂ ਦਾ ਹੁੰਦਾ ਹੈ। ਖੱਬਾ-ਜਾਇਜ਼, ਕੇਂਦਰ-ਜਾਇਜ਼, ਸੱਜੇ-ਜਾਇਜ਼, ਅਤੇ ਜ਼ੀਰੋ-ਫਿਲ ਵੀ ਉਪਲਬਧ ਹਨ। % ਨੂੰ ਵੀ ਇੱਕ ਅੱਖਰ ਵਜੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%