Python ના argparse માં બુલિયન મૂલ્યો સાથે કામ કરતી વખતે સાવચેત રહો

બિઝનેસ

Python માં આદેશ વાક્ય દલીલોને હેન્ડલ કરવા માટે, sys મોડ્યુલના argv અથવા argparse મોડ્યુલોનો ઉપયોગ કરો.

આર્ગપાર્સ મોડ્યુલ કમાન્ડ લાઇન દલીલોના લવચીક સંચાલન માટે પરવાનગી આપે છે, પરંતુ બુલિયન મૂલ્યો (સાચું, ખોટું) સાથે કામ કરતી વખતે કાળજી લેવી જ જોઇએ.

નીચેની માહિતી અહીં આપવામાં આવી છે.

  • દલીલોની સરળ વ્યાખ્યા માટે argparse
  • argparse સાથે દલીલનો પ્રકાર (પ્રકાર) સ્પષ્ટ કરો
  • add_argument() ના દલીલ પ્રકાર તરીકે “બૂલ” નો ઉલ્લેખ કરશો નહીં
  • બૂલ દ્વારા ચુકાદો()
  • દલીલના પ્રકારને બદલે દલીલ ક્રિયાનો ઉપયોગ કરો.
  • strtobool() ફંક્શનનો ઉપયોગ કરીને

દલીલોની સરળ વ્યાખ્યા માટે argparse

આર્ગપાર્સ મોડ્યુલ આદેશ વાક્ય દલીલોને વ્યાખ્યાયિત કરવાનું સરળ બનાવે છે.

argparse મોડ્યુલ વપરાશકર્તા-મૈત્રીપૂર્ણ આદેશ વાક્ય ઇન્ટરફેસ બનાવવાનું સરળ બનાવે છે. તમારા પ્રોગ્રામને કઈ દલીલોની જરૂર છે તે તમે વ્યાખ્યાયિત કરો છો, અને argparse sys.argv માંથી તે વિકલ્પોને કેવી રીતે પાર્સ કરવા તે શોધી કાઢશે. argparse મોડ્યુલ આપમેળે મદદ અને વપરાશ સંદેશાઓ જનરેટ કરે છે, અને જો વપરાશકર્તા પ્રોગ્રામ માટે અમાન્ય દલીલો સ્પષ્ટ કરે તો ભૂલ ઊભી કરે છે. જ્યારે વપરાશકર્તા પ્રોગ્રામ માટે અમાન્ય દલીલો સ્પષ્ટ કરે છે ત્યારે ભૂલ.
argparse — Parser for command-line options, arguments and sub-commands — Python 3.10.0 Documentation

argparse સાથે દલીલનો પ્રકાર (પ્રકાર) સ્પષ્ટ કરો

આર્ગપાર્સનું ઉપયોગી લક્ષણ પ્રકાર (પ્રકાર) ને સ્પષ્ટ કરવાનું છે.

ઉદાહરણ તરીકે, જો તમે પૂર્ણાંક (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 પૂર્ણાંક તરીકે વાંચવામાં આવે છે.

જો બિન-ઇન્ટ મૂલ્યનો દલીલ તરીકે ઉપયોગ કરવામાં આવે, તો એક ભૂલ થશે.

$ 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() ના દલીલ પ્રકાર તરીકે “બૂલ” નો ઉલ્લેખ કરશો નહીં

એ નોંધવું અગત્યનું છે કે બુલ, જેમ કે int અને float, અપેક્ષા મુજબ કામ કરશે નહીં જો તમે bool ને add_argument() ના દલીલ પ્રકાર તરીકે સ્પષ્ટ કરશો.

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'>

જો તમે દલીલ તરીકે ખોટા અથવા અન્ય કોઈ શબ્દમાળાનો ઉપયોગ કરો છો, તો તે સાચું તરીકે વાંચવામાં આવશે.

આવું શા માટે થાય છે તેનું કારણ એ છે કે જ્યારે add_argument() માં type=xxx નો ઉલ્લેખ કરવામાં આવે છે, ત્યારે દલીલ xxx() માં પસાર થાય છે.

ઉદાહરણ તરીકે, જો type=int, તો દલીલ int(); જો type=float, તો float().

તે જ type=bool માટે સાચું છે, જેનો અર્થ છે કે દલીલ bool() માં પસાર થશે.

બૂલ દ્વારા ચુકાદો()

આ bool() એક મુશ્કેલ છે.

નીચેના મૂલ્યોને ખોટા ગણવામાં આવે છે:

  • None
  • false
  • આંકડાકીય પ્રકારોમાં શૂન્ય. ઉદાહરણ તરીકે, નીચેના મૂલ્યો
    • 0
    • 0
    • 0j
  • એક ખાલી ક્રમ. દાખ્લા તરીકે
    • ‘
    • ()
    • []
  • ખાલી મેપિંગ. દાખ્લા તરીકે
    • {}

અન્ય તમામ મૂલ્યો સાચા હોવાનું માનવામાં આવે છે – આમ ઘણા પ્રકારના પદાર્થો હંમેશા સાચા હોય છે. ઓપરેશન્સ અને બિલ્ટ-ઇન ફંક્શન કે જે બુલિયન પરિણામો આપે છે તે હંમેશા ખોટા મૂલ્ય તરીકે 0 અથવા False અને 1 અથવા True સાચા મૂલ્ય તરીકે આપે છે, સિવાય કે અન્યથા નોંધવામાં આવે.

તેથી, તમામ બિન-ખાલી સ્ટ્રીંગ્સ bool(), પછી ભલેને ‘true’ અથવા ‘false’, સાચા પરત આવશે. માત્ર ખાલી શબ્દમાળાઓ ખોટા હશે.

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

print(bool(''))
# False

જ્યારે add_argument() માં type=bool સેટ કરવામાં આવે છે, ત્યારે દલીલ bool() માં પસાર થાય છે. તેથી, ઉપરના ઉદાહરણમાં બતાવ્યા પ્રમાણે, જો false નો ઉપયોગ દલીલ તરીકે થાય છે, તો તે bool() દ્વારા ‘False’ શબ્દમાળા તરીકે રૂપાંતરિત થશે અને સાચું તરીકે વાંચવામાં આવશે.

દલીલના પ્રકારને બદલે દલીલ ક્રિયાનો ઉપયોગ કરો.

જો તમે આર્ગપાર્સમાં બુલિયન મૂલ્યોનો ઉપયોગ કરવા માંગતા હો, તો દલીલ ક્રિયા માટે ‘store_true’ અથવા ‘store_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() નો પણ ઉપયોગ કરી શકો છો.

strtobool() એક કાર્ય છે જે સ્ટ્રિંગને true (1) અથવા false (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))

વળતર મૂલ્ય એ બૂલ પ્રકાર નથી, પરંતુ પૂર્ણાંક પ્રકાર 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'