ਪਾਈਥਨ ਦੇ ਆਰਗਪਾਰਸ ਵਿੱਚ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸਾਵਧਾਨ ਰਹੋ

ਪਾਈਥਨ ਵਿੱਚ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, sys ਮੋਡੀਊਲ ਦੇ argv ਜਾਂ argparse ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।

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

ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।

• ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਆਸਾਨ ਪਰਿਭਾਸ਼ਾ ਲਈ ਆਰਗਪਾਰਸ
• ਆਰਗਪਾਰਸ ਨਾਲ ਆਰਗੂਮੈਂਟ ਦੀ ਕਿਸਮ (ਟਾਈਪ) ਦਿਓ
• add_argument() ਦੀ ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਵਜੋਂ “bool” ਨੂੰ ਨਿਸ਼ਚਿਤ ਨਾ ਕਰੋ
• bool() ਦੁਆਰਾ ਨਿਰਣਾ
• ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਦੀ ਬਜਾਏ ਆਰਗੂਮੈਂਟ ਐਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
• strtobool() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਆਸਾਨ ਪਰਿਭਾਸ਼ਾ ਲਈ ਆਰਗਪਾਰਸ

ਆਰਗਪਾਰਸ ਮੋਡੀਊਲ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

ਆਰਗਪਾਰਸ ਮੋਡੀਊਲ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ ਕਮਾਂਡ ਲਾਈਨ ਇੰਟਰਫੇਸ ਬਣਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਤੁਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਹੜੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ argparse ਇਹ ਪਤਾ ਲਗਾਵੇਗਾ ਕਿ sys.argv ਤੋਂ ਉਹਨਾਂ ਵਿਕਲਪਾਂ ਨੂੰ ਪਾਰਸ ਕਿਵੇਂ ਕਰਨਾ ਹੈ। argparse ਮੋਡੀਊਲ ਸਵੈਚਲਿਤ ਤੌਰ ‘ਤੇ ਮਦਦ ਅਤੇ ਵਰਤੋਂ ਸੁਨੇਹੇ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ ਲਈ ਅਵੈਧ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਤਾਂ ਇੱਕ ਗਲਤੀ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਗਲਤੀ ਜਦੋਂ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ ਲਈ ਅਵੈਧ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ।
argparse — Parser for command-line options, arguments and sub-commands — Python 3.10.0 Documentation

ਆਰਗਪਾਰਸ ਨਾਲ ਆਰਗੂਮੈਂਟ ਦੀ ਕਿਸਮ (ਟਾਈਪ) ਦਿਓ

ਆਰਗਪਾਰਸ ਦੀ ਇੱਕ ਉਪਯੋਗੀ ਵਿਸ਼ੇਸ਼ਤਾ ਕਿਸਮ (ਟਾਈਪ) ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ।

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

ਕਿਸਮ add_argument() ਦੀ ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('arg_int', type=int)

args = parser.parse_args()
print(args.arg_int)
print(type(args.arg_int))

ਇਸ ਫਾਈਲ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਾਓ।

$ python argparse_type_int.py 100
100
<type 'int'>

ਆਰਗੂਮੈਂਟ 100 ਨੂੰ int ਵਜੋਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ।

ਜੇਕਰ ਇੱਕ ਗੈਰ-ਇੰਟ ਮੁੱਲ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਤਰੁੱਟੀ ਆਵੇਗੀ।

$ python argparse_type_int.py foo
usage: argparse_type_int.py [-h] arg_int
argparse_type_int.py: error: argument arg_int: invalid int value: 'foo'

$ python argparse_type_int.py 1.23
usage: argparse_type_int.py [-h] arg_int
argparse_type_int.py: error: argument arg_int: invalid int value: '1.23'

ਅਚਾਨਕ ਦਲੀਲਾਂ ਖੇਡਣ ਲਈ ਬਹੁਤ ਉਪਯੋਗੀ ਹੈ।

add_argument() ਦੀ ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਵਜੋਂ “bool” ਨੂੰ ਨਿਸ਼ਚਿਤ ਨਾ ਕਰੋ

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਜੇਕਰ ਤੁਸੀਂ bool ਨੂੰ add_argument() ਦੀ ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ int ਅਤੇ float ਵਾਂਗ bool, ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ।

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('arg_bool', type=bool)

args = parser.parse_args()
print(args.arg_bool)
print(type(args.arg_bool))

ਇਸ ਫਾਈਲ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਾਓ।

$ python argparse_type_bool.py True
True
<type 'bool'>

ਜੇਕਰ ਸਹੀ ਨੂੰ ਇੱਕ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ‘ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਬੂਲ ਟਾਈਪ ਟਰੂ ਵਜੋਂ ਪੜ੍ਹਿਆ ਜਾਵੇਗਾ। ਇਹ ਸੰਭਾਵਿਤ ਵਿਵਹਾਰ ਹੈ, ਪਰ ਸਮੱਸਿਆ ਹੇਠ ਦਿੱਤੀ ਸਥਿਤੀ ਹੈ।

$ python argparse_type_bool.py False
True
<type 'bool'>

$ python argparse_type_bool.py bar
True
<type 'bool'>

ਜੇਕਰ ਤੁਸੀਂ ਗਲਤ ਜਾਂ ਕਿਸੇ ਹੋਰ ਸਤਰ ਨੂੰ ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ‘ਤੇ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ ਸੱਚ ਵਜੋਂ ਪੜ੍ਹਿਆ ਜਾਵੇਗਾ।

ਅਜਿਹਾ ਹੋਣ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਜਦੋਂ type=xxx ਨੂੰ add_argument() ਵਿੱਚ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਆਰਗੂਮੈਂਟ ਨੂੰ xxx() ਵਿੱਚ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ type=int, ਆਰਗੂਮੈਂਟ ਨੂੰ int(); ਜੇਕਰ type=float, ਤਾਂ float()।

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

ਇਹੀ ਟਾਈਪ=ਬੂਲ ਲਈ ਸੱਚ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਆਰਗੂਮੈਂਟ ਨੂੰ bool() ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ।

bool() ਦੁਆਰਾ ਨਿਰਣਾ

ਇਹ bool() ਇੱਕ ਛਲ ਹੈ।

• bool() — Built-in Functions — Python 3.10.0 Documentation
• Truth Value Testing — Built-in Types — Python 3.10.0 Documentation

ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲਾਂ ਨੂੰ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ:

• None
• false
• ਸੰਖਿਆਤਮਕ ਕਿਸਮਾਂ ਵਿੱਚ ਜ਼ੀਰੋ। ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੇ ਮੁੱਲ
  • 0
  • 0
  • 0j
• ਇੱਕ ਖਾਲੀ ਕ੍ਰਮ। ਉਦਾਹਰਣ ਲਈ
  • ‘
  • ()
  • []
• ਖਾਲੀ ਮੈਪਿੰਗ। ਉਦਾਹਰਣ ਲਈ
  • {}

ਹੋਰ ਸਾਰੇ ਮੁੱਲ ਸੱਚ ਮੰਨੇ ਜਾਂਦੇ ਹਨ – ਇਸ ਤਰ੍ਹਾਂ ਕਈ ਕਿਸਮਾਂ ਦੀਆਂ ਵਸਤੂਆਂ ਹਮੇਸ਼ਾ ਸੱਚ ਹੁੰਦੀਆਂ ਹਨ। ਓਪਰੇਸ਼ਨ ਅਤੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਜੋ ਬੁਲੀਅਨ ਨਤੀਜੇ ਵਾਪਸ ਕਰਦੇ ਹਨ ਹਮੇਸ਼ਾ 0 ਜਾਂ ਗਲਤ ਮੁੱਲ ਦੇ ਤੌਰ ‘ਤੇ ਅਤੇ 1 ਜਾਂ ਸਹੀ ਸਹੀ ਮੁੱਲ ਦੇ ਤੌਰ ‘ਤੇ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਜਦੋਂ ਤੱਕ ਕਿ ਹੋਰ ਨੋਟ ਨਾ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।

ਇਸ ਲਈ, bool() ਨੂੰ ਪਾਸ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਗੈਰ-ਖਾਲੀ ਸਤਰ, ਭਾਵੇਂ ‘ਸੱਚ’ ਜਾਂ ‘ਗਲਤ’, ਸਹੀ ਵਾਪਸ ਆਉਣਗੀਆਂ। ਸਿਰਫ਼ ਖਾਲੀ ਸਤਰਾਂ ਹੀ ਝੂਠੀਆਂ ਹੋਣਗੀਆਂ।

print(bool('True'))
print(bool('False'))
print(bool('abc'))
# True
# True
# True

print(bool(''))
# False

ਜਦੋਂ type=bool ਨੂੰ add_argument() ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਆਰਗੂਮੈਂਟ ਨੂੰ bool() ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਜੇਕਰ ਗਲਤ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ bool() ਦੁਆਰਾ ‘False’ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇਗਾ ਅਤੇ ਸੱਚ ਵਜੋਂ ਪੜ੍ਹਿਆ ਜਾਵੇਗਾ।

ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਦੀ ਬਜਾਏ ਆਰਗੂਮੈਂਟ ਐਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।

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

• store_true’
• store_false’

ਇਹ ‘store_const’ ਦੇ ਵਿਸ਼ੇਸ਼ ਸੰਸਕਰਣ ਹੋਣਗੇ ਜੋ ਕ੍ਰਮਵਾਰ True ਅਤੇ False ਨੂੰ ਸਟੋਰ ਕਰਨਗੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਉਹ ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ False ਅਤੇ True ‘ਤੇ ਸੈੱਟ ਕਰਨਗੇ, ਉਸ ਕ੍ਰਮ ਵਿੱਚ।
argparse — Parser for command-line options, arguments and sub-commands — Python 3.10.0 Documentation

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--en', action='store_true')

args = parser.parse_args()
print(args.en)
print(type(args.en))

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਹੇਠਾਂ ਦਿੱਤੇ ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ।
--enਇਸ ਲਈ, ਜੇਕਰ en ਨੂੰ ਸਹੀ ਦੇ ਤੌਰ ‘ਤੇ ਸੈੱਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਗਲਤ ਵਜੋਂ ਲੋਡ ਕੀਤਾ ਜਾਵੇਗਾ, ਜੋ ਕਿ en ਦਾ ਮੂਲ ਮੁੱਲ ਹੈ।

$ python argparse_option_bool.py --en
True
<type 'bool'>

$ python argparse_option_bool.py
False
<type 'bool'>

ਜੇਕਰ ਤੁਸੀਂ ਡਿਫੌਲਟ ਨੂੰ ਸਹੀ ਅਤੇ ਗਲਤ ‘ਤੇ ਸੈੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਦੋਂ ਵਿਕਲਪ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰੋ।
action='store_false'

strtobool() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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

strtobool() ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸਹੀ (1) ਜਾਂ ਗਲਤ (0) ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

ਬੂਲੀਅਨ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸਹੀ (1) ਜਾਂ ਗਲਤ (0) ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
ਅਸਲ ਮੁੱਲ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹਨ

• y
• yes
• true
• on
• 1

ਗਲਤ ਮੁੱਲ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹਨ।

• n
• no
• f
• false
• off
• 0

ਜੇਕਰ val ਉਪਰੋਕਤ ਵਿੱਚੋਂ ਕੋਈ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ValueError ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ।

9. API Reference – strtobool() — Python 3.10.0 Documentation

ਇਹ ਕੇਸ ਸੰਵੇਦਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ; ਕਿਸੇ ਵੀ ਹੋਰ ਸਤਰ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਗਲਤੀ ਹੋਵੇਗੀ।

• TRUE'
• True'
• YES'

from distutils.util import strtobool

print(strtobool('true'))
print(strtobool('True'))
print(strtobool('TRUE'))
# 1
# 1
# 1

print(strtobool('t'))
print(strtobool('yes'))
print(strtobool('y'))
print(strtobool('on'))
print(strtobool('1'))
# 1
# 1
# 1
# 1
# 1

print(strtobool('false'))
print(strtobool('False'))
print(strtobool('FALSE'))
# 0
# 0
# 0

print(strtobool('f'))
print(strtobool('no'))
print(strtobool('n'))
print(strtobool('off'))
print(strtobool('0'))
# 0
# 0
# 0
# 0
# 0

# print(strtobool('abc'))
# ValueError: invalid truth value 'abc'

ਨਾਮ strtobool() ਹੈ, ਪਰ ਵਾਪਸੀ ਦਾ ਮੁੱਲ bool ਨਹੀਂ ਹੈ, ਪਰ int (1 ਜਾਂ 0) ਹੈ।

print(type(strtobool('true')))
# <class 'int'>

ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਜਦੋਂ argparse ਦੇ add_argument() ਵਿੱਚ type=xxx ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਆਰਗੂਮੈਂਟ ਨੂੰ xxx() ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਾਂ.
type=strtobool

import argparse
from distutils.util import strtobool

parser = argparse.ArgumentParser()
parser.add_argument('arg_bool', type=strtobool)

args = parser.parse_args()
print(args.arg_bool)
print(type(args.arg_bool))

ਵਾਪਸੀ ਦਾ ਮੁੱਲ ਇੱਕ ਬੂਲ ਕਿਸਮ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ int ਕਿਸਮ 1 ਜਾਂ 0 ਹੈ, ਪਰ ਇਹ ਸਹੀ ਜਾਂ ਗਲਤ ਮੁੱਲਾਂ ਨੂੰ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਸਹੀ ਜਾਂ ਗਲਤ ਨਾਲ ਪੜ੍ਹ ਸਕਦਾ ਹੈ।

$ python argparse_type_strtobool.py true
1
<type 'int'>

$ python argparse_type_strtobool.py false
0
<type 'int'>

ਨਾਲ ਹੀ, ਜੇਕਰ ਦਲੀਲ ਦੀ ਉਮੀਦ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਕੀਤੀ ਜਾਵੇਗੀ।

$ python argparse_type_strtobool.py bar
usage: argparse_type_strtobool.py [-h] arg_bool
argparse_type_strtobool.py: error: argument arg_bool: invalid strtobool value: 'bar'