Python’s argparse හි Boolean අගයන් සමඟ කටයුතු කිරීමේදී ප්‍රවේශම් වන්න

Python හි විධාන රේඛා තර්ක හැසිරවීමට, sys මොඩියුලයේ argv හෝ argparse මොඩියුල භාවිතා කරන්න.

argparse මොඩියුලය විධාන රේඛා තර්ක නම්‍යශීලී ලෙස හැසිරවීමට ඉඩ සලසයි, නමුත් Boolean අගයන් (සත්‍ය, අසත්‍ය) සමඟ කටයුතු කිරීමේදී සැලකිලිමත් විය යුතුය.

පහත තොරතුරු මෙහි දක්වා ඇත.

• තර්ක පහසුවෙන් අර්ථ දැක්වීම සඳහා argparse
• argparse සමඟ තර්කයේ වර්ගය (වර්ගය) සඳහන් කරන්න
• add_argument() හි තර්ක වර්ගය ලෙස “bool” සඳහන් නොකරන්න
• bool () අනුව විනිශ්චය
• තර්ක වර්ගය වෙනුවට තර්ක ක්‍රියාව භාවිතා කරන්න.
• strtobool() ශ්‍රිතය භාවිතා කිරීම

තර්ක පහසුවෙන් අර්ථ දැක්වීම සඳහා argparse

argparse මොඩියුලය විධාන රේඛා තර්ක නිර්වචනය කිරීම පහසු කරයි.

argparse මොඩියුලය පරිශීලක-හිතකාමී විධාන රේඛා අතුරුමුහුණත් නිර්මාණය කිරීම පහසු කරයි. ඔබේ වැඩසටහනට අවශ්‍ය තර්ක මොනවාදැයි ඔබ නිර්වචනය කරයි, සහ sys.argv වෙතින් එම විකල්පයන් විග්‍රහ කරන්නේ කෙසේදැයි argparse විසින් සොයා ගනු ඇත. argparse මොඩියුලය ස්වයංක්‍රීයව උදව් සහ භාවිත පණිවිඩ ජනනය කරයි, සහ පරිශීලකයා වැඩසටහනට වලංගු නොවන තර්ක නියම කළහොත් දෝෂයක් ඇති කරයි. පරිශීලකයා වැඩසටහනට වලංගු නොවන තර්ක නියම කරන විට දෝෂයකි.
argparse — Parser for command-line options, arguments and sub-commands — Python 3.10.0 Documentation

argparse සමඟ තර්කයේ වර්ගය (වර්ගය) සඳහන් කරන්න

argparse හි ප්‍රයෝජනවත් අංගයක් වන්නේ වර්ගය (වර්ගය) සඳහන් කිරීමයි.

උදාහරණයක් ලෙස, ඔබ integer (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 ලෙසය.

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” සඳහන් නොකරන්න

ඔබ add_argument() හි තර්ක වර්ගය ලෙස bool සඳහන් කරන්නේ නම්, 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'>

true යන්න තර්කයක් ලෙස භාවිතා කරන්නේ නම්, එය bool වර්ගය true ලෙස කියවනු ලැබේ. මෙය අපේක්ෂිත හැසිරීමයි, නමුත් ගැටළුව පහත දැක්වෙන අවස්ථාවයි.

$ 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().

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

type=bool සඳහාද එයම සත්‍ය වේ, එනම් තර්කය 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
• හිස් අනුපිළිවෙලක්. උදාහරණ වශයෙන්
  • ‘
  • ()
  • []
• හිස් සිතියම්කරණය. උදාහරණ වශයෙන්
  • {}

අනෙකුත් සියලුම අගයන් සත්‍ය යැයි උපකල්පනය කෙරේ – එබැවින් බොහෝ වර්ගවල වස්තූන් සැමවිටම සත්‍ය වේ. Boolean ප්‍රතිඵල ලබා දෙන මෙහෙයුම් සහ ගොඩනඟන ලද ශ්‍රිතයන් වෙනත් ආකාරයකින් සටහන් කර නොමැති නම්, සෑම විටම 0 හෝ False වැරදි අගය ලෙස සහ 1 හෝ True සත්‍ය අගය ලෙස ලබා දෙයි.

එබැවින්, bool() වෙත ගිය සියලුම හිස් නොවන තන්තු ‘සත්‍ය’ හෝ ‘අසත්‍ය’ වේවා, සත්‍ය ආපසු එනු ඇත. හිස් නූල් පමණක් අසත්‍ය වනු ඇත.

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

print(bool(''))
# False

add_argument() හි type=bool සැකසූ විට, තර්කය bool() වෙත යවනු ලැබේ. එබැවින් ඉහත උදාහරණයේ පෙන්වා ඇති පරිදි, තර්කය ලෙස අසත්‍යය භාවිතා කරන්නේ නම්, එය bool() මඟින් ‘False’ තන්තුව ලෙස පරිවර්තනය කර සත්‍ය ලෙස කියවනු ඇත.

තර්ක වර්ගය වෙනුවට තර්ක ක්‍රියාව භාවිතා කරන්න.

ඔබට argparse හි Boolean අගයන් භාවිතා කිරීමට අවශ්‍ය නම්, තර්ක ක්‍රියාව සඳහා ‘store_true’ හෝ ‘store_false’ සඳහන් කරන්න.

• store_true’
• store_false’

මේවා පිළිවෙලින් True සහ False ගබඩා කරන ‘store_const’ හි විශේෂ අනුවාද වේ. ඊට අමතරව, ඔවුන් එම අනුපිළිවෙලින් පෙරනිමි අගයන් පිළිවෙලින් අසත්‍ය සහ සත්‍ය ලෙස සකසනු ඇත.
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))

ආපසු ලැබෙන අගය 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'