How to Create a Command Line Program in Python with Click

This step-by-step guide explains how to create a command line program in python with select. It covers the required setup, the main actions, and the checks that help prevent common problems.

You can write command line programs without clicking but requires more skills and code. You need to parse the command, perform authentication, develop logic to handle various parameters and build a custom help menu. If you want to add a new option, you need to modify the help function.

It is useful to be able to write your own code, this is a great way to learn Python programming language, but select allows you to follow the 'Don't Repeat Yourself' principle (Don't repeat anything). Same - DRY). If you do not use select, you will have to write the code yourself and maintain it whenever there is a change.

This is a simple command line interface that is code without clicking:

 import sys 
 import random 

 def do_work (): 
 "" "Function to handle command line usage" "" 
 args = sys.argv 
 args = args [1:] # First element of args is the file name 

 if len (args) == 0: 
 in ra ('Bạn không đưa ra một câu lệnh trong!') 
 else: 
 cho một trong args: 
 if a == '--help': 
 print ('Basic command line program') 
 print ('Options:') 
 print ('--help -> show this basic help menu.') 
 print ('--monty -> show a Monty Python quote.') 
 print ('--veg -> show a random vegetable') 
 elif a == '--monty': 
 print ('What's this, then? "Romanes eunt domus?" People called Romanes, they go, the house? ") 
 elif a == '--veg': 
 print (random.choice (['Carrot', 'Potato', 'Turnip'])) 
 else: 
 print ('Unrecognised argument.') 

 if __name__ == '__main__': 
 do_work () 

These 27 Python lines work well but are fragile. When making any changes on the program, you also need to change the other support code. If you change a parameter name, you need to update the help information and often get confused.

This is the same logic but used with select:

 import click 
 import random 
 @ click.command () 
 @ click.option ('- monty', default = False, help = 'Show a Monty Python quote.') 
 @ click.option ('- veg', default = False, help = 'Show a random vegetable.') 
 def do_work (monty, veg): 
 "" "Basic Click example will follow your commands" "" 
 if monty: 
 print ('What's this, then? "Romanes eunt domus?" People called Romanes, they go, the house? ") 
 if veg: 
 print (random.choice (['Carrot', 'Potato', 'Turnip'])) 
 if __name__ == '__main__': 
 do_work () 

You can see that select performs the same logic but only with 16 lines of code instead of the 27 lines of code above. And you don't need parametric analysis and it will create a help screen.

This is just a basic comparison example so you can see that using programs like select will save you a lot of time and effort. Although the command line interface to the end user is the same, the code that makes up the program is simpler, saving you a lot of time writing code.

Before using select, you can configure a virtual environment. This will prevent Python packages from conflicting with the Python system or other projects you are working on. You can try Python in your browser if you want to learn more about Python and select.

To finish, make sure you're running Python version 3. Although select can be used with Python version 2, the examples here are in Python 3.

Select Settings from the command line using PIP.

 pip install click 

In the text editor, start by entering select:

 import click 

After entering select, create a Method And Main Entry point.

 import click 
 import random 

 def veg (): 
 "" "Basic method will return a random vegetable" "" 
 print (random.choice (['Carrot', 'Potato', 'Turnip', 'Parsnip'])) 

 if __name__ == '__main__': 
 veg () 

This simple script will produce a random vegetable. Your code may be different but this simple example is the perfect way to connect to select.

Save it to Click_example. Py And then run it in the command line (after navigating to its location):

 > python click_example.py 

You will see the vegetable name randomly, now improve this code by adding select. Change your code to contain decorators and For In Python loops:

 @ click.command () 
 @ click.option ('- total', default = 3, help = 'Number of vegetables to output.') 
 def veg (total): 
 "" "Basic method will return a random vegetable" "" 
 cho số trong phạm vi (total): 
 print (random.choice (['Carrot', 'Potato', 'Turnip', 'Parsnip'])) 

 if __name__ == '__main__': 
 veg () 

When running, you will see a random vegetable displayed three times. Let's analyze the above code.

Decorator @ select. Command () Configures select to work with Python functions right after decorator. In this case, this is the Veg () Function. You need it for the methods used with select.

Decorator @ select. Option Configuration select to accept the parameter from the command line, move to your method. There are three parameters used here:

• -Total : This is the command line name for the Total Parameter.
• Default : If you don't specify the total parameter when using the script, select will use the default value.
• Help : This is a short sentence that explains how to use the program.

See the actual example using select. From the command line, run the script but pass the total parameter as follows:

 python click_example.py --total 10 

When the -total Setting is 10 From the command line, the script will print 10 random vegetables. If you use the -help Flag, you will see a help page with options you can use:

 python click_example.py --help 

You can use multiple select decorators on the same function. Add another select option to the Veg Function as follows:

 @ click.option ('- gravy', default = False, help = 'Append "with gravy" to the vegetables. ") 

However, do not forget to pass it into the method:

 def veg (total, gravy): 

Now when you run the file, you can transfer it in the flag Gravy :

 python click_example.py --gravy y 

The help screen also changes:

This is the whole code (with some small code changes to look more neat):

 import click 
 import random 

 @ click.command () 
 @ click.option ('- gravy', default = False, help = 'Append "with gravy" to the vegetables. ") 
 @ click.option ('- total', default = 3, help = 'Number of vegetables to output.') 
 def veg (total, gravy): 
 "" "Basic method will return a random vegetable" "" 
 cho số trong phạm vi (total): 
 choice = random.choice (['Carrot', 'Potato', 'Turnip', 'Parsnip']) 

 if gravy: 
 print (f '{choice} with gravy') 
 else: 
 print (choice) 

 if __name__ == '__main__': 
 veg () 

Once you know the basics of Clicking, you can start to look at the more complex select options. In this example, you will learn how to pass some values into a parameter to select convert to a tuple data type.

Create a new file named Click_example_2. Py . This is the code you need:

 import click 
 import random 

 @ click.command () 
 def add (): 
 "" Basic method will add two numbers together. "" " 
 pass 

 if __name__ == '__main__': 
 add () 

Next, add @ select. Option Called Numbers :

 @ click.option ('- numbers'>, nargs = 2, type = int, help = 'Add two numbers together.') 

The only new code here is Nargs = 2 , and the Type = int option For select to accept two values for the Numbers Option and both must be integers. You can change any number or value type (valid) you like.

To finish, change the Add Method to accept the parameter parameter and make some changes to them:

 def add (numbers): 
 "" Basic method will add two numbers together. "" " 
 result = numbers [0] + numbers [1] 
 print (f '{numbers [0]} + {numbers [1]} = {result}') 

Each value you pass can be accessed via object Numbers . Here's how to use it in the command line:

 python click_example_2.py --numbers 1 2