परिचय

पायथन व्यापक रूप से अपनी बहुमुखी प्रतिभा और उपयोग में आसानी के लिए जाना जाता है, खासकर कमांड-लाइन इंटरफ़ेस (सीएलआई) अनुप्रयोगों का निर्माण करते समय। चाहे आप सांसारिक कार्यों को स्वचालित करना चाहते हों, डेवलपर टूल बनाना चाहते हों, या लचीली स्क्रिप्ट बनाना चाहते हों, पायथन का समृद्ध पारिस्थितिकी तंत्र सीएलआई को कुशलतापूर्वक संभालने के लिए विभिन्न पुस्तकालय प्रदान करता है।

इस ब्लॉग पोस्ट में, हम निम्नलिखित को कवर करते हुए पायथन में सीएलआई के साथ काम करने पर गहराई से विचार करेंगे:

• सीएलआई क्यों बनाएं?
• सीएलआई के निर्माण के लिए पायथन मॉड्यूल
• कमांड-लाइन तर्कों की मूल बातें
• Argparse का उपयोग करके उन्नत सुविधाएँ
• क्लिक के साथ सीएलआई उपकरण बनाना
• सीएलआई टूल्स में त्रुटि प्रबंधन
• वितरण के लिए पैकेजिंग सीएलआई उपकरण

इस पोस्ट के अंत तक, आप मजबूत और उपयोगकर्ता के अनुकूल कमांड-लाइन एप्लिकेशन बनाने में सक्षम होंगे।

सीएलआई क्यों बनाएं?

सीएलआई का व्यापक रूप से सिस्टम प्रशासन, डेटा प्रोसेसिंग और सॉफ्टवेयर विकास में उपयोग किया जाता है क्योंकि वे पेशकश करते हैं:

1. स्वचालन: समय बचाने और त्रुटियों को कम करने के लिए दोहराए जाने वाले कार्यों को स्क्रिप्ट करें।
2. सरलता: कुछ कीस्ट्रोक्स के साथ जटिल कमांड चलाएं।
3. पोर्टेबिलिटी: एक अच्छी तरह से निर्मित सीएलआई उपकरण का उपयोग बिना जीयूआई के किसी भी मशीन पर किया जा सकता है।
4. डेवलपर टूल्स: कई डेव टूल्स (जैसे गिट, एनपीएम और पिप) सीएलआई-आधारित हैं।

सीएलआई विकास के लिए पायथन मॉड्यूल

पायथन सीएलआई उपकरण बनाने के लिए कई लाइब्रेरी प्रदान करता है:

1. sys.argv: कमांड-लाइन तर्कों तक सीधी पहुंच, छोटी, सरल स्क्रिप्ट के लिए उपयुक्त।
2. argparse: स्वचालित सहायता पीढ़ी के साथ कमांड-लाइन तर्कों को संभालने के लिए अंतर्निहित मॉड्यूल।
3. क्लिक करें: जटिल सीएलआई एप्लिकेशन बनाने के लिए एक शक्तिशाली और लचीली लाइब्रेरी।
4. टाइपर: क्लिक के शीर्ष पर बनी एक आधुनिक लाइब्रेरी, जो उपयोग में आसानी के लिए पायथन प्रकार के संकेतों का उपयोग करती है।

sys.argv के साथ कार्य करना

sys.argv कमांड-लाइन तर्कों तक पहुंचने का एक बुनियादी तरीका है। यह कमांड-लाइन तर्कों को एक सूची के रूप में संग्रहीत करता है, जहां पहला तत्व हमेशा स्क्रिप्ट नाम होता है।

import sys

# Command-line arguments
print(f"Script Name: {sys.argv[0]}")
print(f"Arguments: {sys.argv[1:]}")

स्क्रिप्ट चल रहा है:

$ python script.py arg1 arg2 arg3
Script Name: script.py
Arguments: ['arg1', 'arg2', 'arg3']

sys.argv की सीमाएं:

• कोई प्रकार की जांच नहीं: सभी इनपुट को स्ट्रिंग के रूप में माना जाता है।
• कोई अंतर्निहित सहायता संदेश नहीं: आपको इनपुट को मैन्युअल रूप से सत्यापित करने और उपयोग की जानकारी प्रदर्शित करने की आवश्यकता है।

Argparse के साथ सीएलआई का निर्माण

आर्गपर्स मॉड्यूल सीएलआई बनाने के लिए पायथन की मानक लाइब्रेरी है। यह sys.argv की तुलना में अधिक नियंत्रण प्रदान करता है और स्वचालित रूप से सहायता संदेश और त्रुटि प्रबंधन उत्पन्न करता है।

मूल उदाहरण:

import argparse

parser = argparse.ArgumentParser(description="A simple CLI tool")
parser.add_argument("name", help="Your name")
parser.add_argument("--greet", help="Custom greeting", default="Hello")

args = parser.parse_args()

print(f"{args.greet}, {args.name}!")

स्क्रिप्ट चल रहा है:

$ python script.py Alice
Hello, Alice!

$ python script.py Alice --greet Hi
Hi, Alice!

आर्गपर्स की मुख्य विशेषताएं:

1. स्थितिगत और वैकल्पिक तर्क: आवश्यक और वैकल्पिक मापदंडों को आसानी से परिभाषित करें।
2. प्रकार की जांच: सुनिश्चित करें कि उपयोगकर्ता सही डेटा प्रकार प्रदान करता है।
3. विकल्प: विकल्प पैरामीटर का उपयोग करके इनपुट को विशिष्ट मानों तक सीमित करें।
4. सहायता संदेश: -h या --help ध्वज के साथ स्वचालित रूप से सहायता उत्पन्न करें।

प्रकार की जांच और विकल्पों के साथ उदाहरण:

parser.add_argument("age", type=int, help="Your age")
parser.add_argument("--format", choices=["json", "xml"], help="Output format")

स्क्रिप्ट चल रहा है:

$ python script.py Alice 30 --format json

क्लिक के साथ उन्नत सीएलआई उपकरण

क्लिक कमांड-लाइन इंटरफेस बनाने के लिए एक अधिक उन्नत लाइब्रेरी है। यह कमांड, उपकमांड और विकल्पों को परिभाषित करने के लिए डेकोरेटर-आधारित दृष्टिकोण प्रदान करता है।

क्लिक का उपयोग क्यों करें?

• बेहतर पठनीयता: एक अधिक पायथोनिक, डेकोरेटर-आधारित वाक्यविन्यास।
• स्वचालित तर्क सत्यापन: सुनिश्चित करता है कि तर्क ठीक से मान्य हैं।
• पुन: प्रयोज्य घटक: कमांड, विकल्प और तर्कों का आपके एप्लिकेशन के विभिन्न हिस्सों में आसानी से पुन: उपयोग किया जा सकता है।

क्लिक का उपयोग करने का मूल उदाहरण:

import click

@click.command()
@click.option('--name', prompt='Your name', help='The person to greet.')
@click.option('--greet', default="Hello", help='Greeting to use.')
def greet(name, greet):
    """Simple program that greets NAME with a GREET."""
    click.echo(f'{greet}, {name}!')

if __name__ == '__main__':
    greet()

स्क्रिप्ट चल रहा है:

$ python greet.py --name Alice --greet Hi
Hi, Alice!

क्लिक के साथ उपकमांड:

आप एकाधिक उपकमांडों के साथ अधिक जटिल सीएलआई उपकरण बना सकते हैं।

import click

@click.group()
def cli():
    pass

@cli.command()
def start():
    click.echo("Starting the application...")

@cli.command()
def stop():
    click.echo("Stopping the application...")

if __name__ == '__main__':
    cli()

स्क्रिप्ट चल रहा है:

$ python app.py start
Starting the application...

$ python app.py stop
Stopping the application...

सीएलआई टूल्स में त्रुटि प्रबंधन

कोई फर्क नहीं पड़ता कि आप किस लाइब्रेरी का उपयोग करते हैं, एक सहज उपयोगकर्ता अनुभव प्रदान करने के लिए त्रुटि प्रबंधन महत्वपूर्ण है।

आर्गपर्से में उदाहरण:

यदि कोई आवश्यक तर्क गुम है, तो argparse एक त्रुटि देगा और उपयोग निर्देश प्रदर्शित करेगा:

$ python script.py
usage: script.py [-h] name
script.py: error: the following arguments are required: name

क्लिक में त्रुटि प्रबंधन:

क्लिक में, आप कस्टम अपवाद बढ़ा सकते हैं और डेकोरेटर्स का उपयोग करके त्रुटियों को खूबसूरती से संभाल सकते हैं।

@click.command()
@click.option('--count', type=int, help='Number of repetitions')
def repeat(count):
    if count is None or count 







  
  
  आर्गपर्स और क्लिक को अन्य पुस्तकालयों के साथ संयोजित करना


सीएलआई कार्यक्षमता को बढ़ाने के लिए, आप आर्गपर्स या क्लिक को अन्य लाइब्रेरी जैसे ओएस, सबप्रोसेस, या यहां तक ​​कि कस्टम लाइब्रेरी के साथ जोड़ सकते हैं।


  
  
  उदाहरण: ओएस के साथ आर्गपर्स का संयोजन




import os
import argparse

parser = argparse.ArgumentParser(description="File operations CLI")
parser.add_argument("filename", help="Name of the file to check")
parser.add_argument("--create", action="store_true", help="Create the file if it does not exist")

args = parser.parse_args()

if os.path.exists(args.filename):
    print(f"{args.filename} already exists.")
else:
    if args.create:
        with open(args.filename, 'w') as f:
            f.write("New file created.")
        print(f"{args.filename} created.")
    else:
        print(f"{args.filename} does not exist.")




स्क्रिप्ट चल रहा है:



$ python filecli.py example.txt --create
example.txt created.








  
  
  आपके सीएलआई टूल की पैकेजिंग


अपने सीएलआई टूल को वितरित करने के लिए, आप इसे सेटअपटूल्स का उपयोग करके पैकेज कर सकते हैं और इसे किसी भी सिस्टम पर विश्व स्तर पर पहुंच योग्य बना सकते हैं।


  
  
  चरण 1: एक setup.py फ़ाइल बनाएं




from setuptools import setup

setup(
    name='greet-cli',
    version='0.1',
    py_modules=['greet'],
    install_requires=[
        'click',
    ],
    entry_points='''
        [console_scripts]
        greet=greet:greet
    ''',
)





  
  
  चरण 2: अपना सीएलआई स्थानीय रूप से स्थापित करें




$ pip install --editable .




अब, ग्रीट कमांड विश्व स्तर पर उपलब्ध है:



$ greet --name Alice
Hello, Alice!





  
  
  पीईपीआई पर वितरित करें


अपने टूल को सार्वजनिक रूप से वितरित करने के लिए, एक PyPI खाता बनाएं और अपना पैकेज अपलोड करने के लिए चरणों का पालन करें:


पैकेज बनाएं:



   python setup.py sdist bdist_wheel





पैकेज अपलोड करें:



   twine upload dist/*








  
  
  सीएलआई के निर्माण के लिए सर्वोत्तम अभ्यास




स्पष्ट सहायता संदेश प्रदान करें: उपयोगकर्ताओं का मार्गदर्शन करने के लिए हमेशा --help शामिल करें।

इनपुट मान्य करें: प्रकार की जांच का उपयोग करें और अपवादों को शालीनता से संभालें।

सहज ज्ञान युक्त कमांड डिज़ाइन करें: सुनिश्चित करें कि आपकी कमांड संरचना तार्किक और उपयोग में आसान है।

एज केस के साथ परीक्षण करें: सुनिश्चित करें कि आपका सीएलआई टूल अमान्य इनपुट के साथ भी सही ढंग से व्यवहार करता है।

अपने कोड को मॉड्यूलर करें: आसान परीक्षण और रखरखाव के लिए अपने कमांड-लाइन तर्क को अपनी मुख्य कार्यक्षमता से अलग रखें।






  
  
  निष्कर्ष


पायथन कमांड-लाइन इंटरफ़ेस (सीएलआई) अनुप्रयोगों के निर्माण के लिए एक उत्कृष्ट टूलकिट प्रदान करता है। चाहे आप बिल्ट-इन आर्गपर्स मॉड्यूल या अधिक सुविधा संपन्न क्लिक का उपयोग कर रहे हों, आप शक्तिशाली, उपयोगकर्ता-अनुकूल उपकरण बना सकते हैं जो वर्कफ़्लो को स्वचालित कर सकते हैं, डेटा संसाधित कर सकते हैं और उत्पादकता बढ़ा सकते हैं।

अब जब आपने पायथन में सीएलआई के साथ काम करने की मूल बातें और उन्नत विशेषताएं सीख ली हैं, तो इसे अभ्यास में लाने का समय आ गया है। अपना स्वयं का टूल बनाएं, इसे साझा करें, या यहां तक ​​कि इसे विश्व स्तर पर वितरित करें!




प्रश्नों या सुझावों के साथ बेझिझक संपर्क करें:

• लिंक्डइन
• गिटहब