పైథాన్ ఆర్గ్‌పార్స్‌లో బూలియన్ విలువలతో వ్యవహరించేటప్పుడు జాగ్రత్తగా ఉండండి

వ్యాపారం

పైథాన్‌లో కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను నిర్వహించడానికి, sys మాడ్యూల్ యొక్క argv లేదా argparse మాడ్యూల్‌లను ఉపయోగించండి.

ఆర్గ్‌పార్స్ మాడ్యూల్ కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల అనువైన నిర్వహణను అనుమతిస్తుంది, అయితే బూలియన్ విలువలతో (నిజం, తప్పు) వ్యవహరించేటప్పుడు జాగ్రత్త తీసుకోవాలి.

కింది సమాచారం ఇక్కడ అందించబడింది.

  • ఆర్గ్యుమెంట్స్ యొక్క సులభమైన నిర్వచనం కోసం argparse
  • ఆర్గ్‌పార్స్‌తో ఆర్గ్యుమెంట్ (రకం) రకాన్ని పేర్కొనండి
  • add_argument() యొక్క వాదన రకంగా “bool”ని పేర్కొనవద్దు
  • bool() ద్వారా తీర్పు
  • వాదన రకానికి బదులుగా వాదన చర్యను ఉపయోగించండి.
  • strtobool() ఫంక్షన్‌ని ఉపయోగించడం

ఆర్గ్యుమెంట్స్ యొక్క సులభమైన నిర్వచనం కోసం argparse

ఆర్గ్‌పార్స్ మాడ్యూల్ కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను నిర్వచించడాన్ని సులభతరం చేస్తుంది.

argparse మాడ్యూల్ వినియోగదారు-స్నేహపూర్వక కమాండ్ లైన్ ఇంటర్‌ఫేస్‌లను సృష్టించడాన్ని సులభతరం చేస్తుంది. మీ ప్రోగ్రామ్‌కు ఏ ఆర్గ్యుమెంట్‌లు అవసరమో మీరు నిర్వచించారు మరియు sys.argv నుండి ఆ ఎంపికలను ఎలా అన్వయించాలో argparse కనుగొంటుంది. argparse మాడ్యూల్ స్వయంచాలకంగా సహాయం మరియు వినియోగ సందేశాలను ఉత్పత్తి చేస్తుంది మరియు వినియోగదారు ప్రోగ్రామ్‌కు చెల్లని ఆర్గ్యుమెంట్‌లను పేర్కొన్నట్లయితే లోపాన్ని లేవనెత్తుతుంది. వినియోగదారు ప్రోగ్రామ్‌కు చెల్లని ఆర్గ్యుమెంట్‌లను పేర్కొన్నప్పుడు లోపం.
argparse — Parser for command-line options, arguments and sub-commands — Python 3.10.0 Documentation

ఆర్గ్‌పార్స్‌తో ఆర్గ్యుమెంట్ (రకం) రకాన్ని పేర్కొనండి

argparse యొక్క ఉపయోగకరమైన లక్షణం రకాన్ని (రకం) పేర్కొనడం.

ఉదాహరణకు, మీరు పూర్ణాంకం (పూర్ణాంక) రకాన్ని పేర్కొన్నట్లయితే, అది స్వయంచాలకంగా ఆర్గ్యుమెంట్‌ను పూర్ణాంకానికి మారుస్తుంది మరియు పూర్ణాంకానికి లేని ఆర్గ్యుమెంట్‌ల కోసం లోపాన్ని కూడా పెంచుతుంది.

రకం 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() యొక్క వాదన రకంగా “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'>

మీరు తప్పు లేదా ఏదైనా ఇతర స్ట్రింగ్‌ను వాదనగా ఉపయోగిస్తే, అది నిజం అని చదవబడుతుంది.

ఇలా జరగడానికి కారణం add_argument()లో type=xxxని పేర్కొన్నప్పుడు, ఆర్గ్యుమెంట్ xxx()కి పంపబడుతుంది.

ఉదాహరణకు, type=int అయితే, వాదన int()కి పంపబడుతుంది; టైప్=ఫ్లోట్ అయితే, ఫ్లోట్().

టైప్=బూల్‌కి కూడా ఇదే వర్తిస్తుంది, అంటే ఆర్గ్యుమెంట్ bool()కి పంపబడుతుంది.

bool() ద్వారా తీర్పు

ఈ bool() ఒక గమ్మత్తైనది.

కింది విలువలు తప్పుగా పరిగణించబడతాయి:

  • None
  • false
  • సంఖ్యా రకాలుగా సున్నా. ఉదాహరణకు, క్రింది విలువలు
    • 0
    • 0
    • 0j
  • ఖాళీ సీక్వెన్స్. ఉదాహరణకి
    • ‘
    • ()
    • []
  • ఖాళీ మ్యాపింగ్. ఉదాహరణకి
    • {}

అన్ని ఇతర విలువలు నిజమైనవిగా భావించబడతాయి – అందువలన అనేక రకాల వస్తువులు ఎల్లప్పుడూ నిజమైనవి. బూలియన్ ఫలితాలను అందించే కార్యకలాపాలు మరియు అంతర్నిర్మిత ఫంక్షన్‌లు ఎల్లప్పుడూ 0 లేదా తప్పుని తప్పుడు విలువగా మరియు 1 లేదా నిజమైన విలువగా గుర్తించబడకపోతే, అందిస్తాయి.

అందువల్ల, bool()కి పంపబడిన అన్ని ఖాళీ కాని స్ట్రింగ్‌లు ‘ఒప్పు’ లేదా ‘తప్పు’ అయినా సరే, తిరిగి వస్తాయి. ఖాళీ తీగలు మాత్రమే తప్పుగా ఉంటాయి.

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

print(bool(''))
# False

add_argument()లో టైప్=బూల్ సెట్ చేసినప్పుడు, ఆర్గ్యుమెంట్ bool()కి పంపబడుతుంది. కాబట్టి, పై ఉదాహరణలో చూపిన విధంగా, తప్పుడు వాదనగా ఉపయోగించినట్లయితే, అది bool() ద్వారా స్ట్రింగ్ ‘తప్పు’గా మార్చబడుతుంది మరియు నిజమైనదిగా చదవబడుతుంది.

వాదన రకానికి బదులుగా వాదన చర్యను ఉపయోగించండి.

మీరు argparseలో బూలియన్ విలువలను ఉపయోగించాలనుకుంటే, వాదన చర్య కోసం ‘store_true’ లేదా ‘store_false’ని పేర్కొనండి.

  • store_true’
  • store_false’

ఇవి ‘store_const’ యొక్క ప్రత్యేక సంస్కరణలు, ఇవి వరుసగా True మరియు Falseని నిల్వ చేస్తాయి. అదనంగా, వారు ఆ క్రమంలో డిఫాల్ట్ విలువలను వరుసగా తప్పు మరియు ఒప్పుకు సెట్ చేస్తారు.
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() అనేది స్ట్రింగ్‌ను నిజమైన (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))

రిటర్న్ విలువ బూల్ రకం కాదు, కానీ పూర్ణాంక రకం 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'
Copied title and URL