COMMAND LINE
ARGUMENTS IN PYTHON
WHAT ARE COMMAND LINE ARGUMENTS IN
PYTHON?
EXAMPLE: PYTHON [Link] 10 HELLO 3.5
• HERE:10,HELLO,3.5 ARE ARGUMENTS GIVEN TO THE PROGRAM.
• PYTHON RECEIVES THESE ARGUMENTS THROUGH A LIST CALLED [Link].
HOW PYTHON HANDLES COMMAND LINE
ARGUMENTS?
PYTHON STORES ALL COMMAND LINE ARGUMENTS INSIDE THE LIST:
• IMPORT SYS
• PRINT([Link])
• IMPORTANT POINTS:
• [Link][0] → NAME OF THE SCRIPT (EX: "[Link]")
• [Link][1] → FIRST ARGUMENT
• [Link][2] → SECOND ARGUMENT
• …
• ARGUMENTS ARE ALWAYS RECEIVED AS STRINGS, EVEN IF THEY LOOK LIKE NUMBERS.
EXAMPLE 1: BASIC COMMAND LINE
ARGUMENTS:
PROGRAM: [Link]
IMPORT SYS
PRINT("ALL ARGUMENTS:", [Link])
PRINT("SCRIPT NAME:", [Link][0])
PRINT("FIRST ARGUMENT:", [Link][1])
PRINT("SECOND ARGUMENT:", [Link][2])
RUN IN TERMINAL:
PYTHON [Link] APPLE BANANA
OUTPUT:ALL ARGUMENTS: ['[Link]', 'APPLE', 'BANANA']
SCRIPT NAME: [Link]
FIRST ARGUMENT: APPLE
SECOND ARGUMENT: BANANA
EXAMPLE 2:SUM OF TWO NUMBERS FROM
COMMAND LINE:
IMPORT SYS
# TAKE VALUES FROM COMMAND LINE
NUM1 = INT([Link][1]) # CONVERT STRING TO INT
NUM2 = INT([Link][2])
RESULT = NUM1 + NUM2
PRINT("SUM =", RESULT)
PYTHON [Link] 20 30
OUTPUT:
SUM = 50
EXAMPLE 3: HANDLING ANY NUMBER OF
ARGUMENTS:
IMPORT SYS
ARGS = [Link][1:] # IGNORE SCRIPT NAME
TOTAL = 0
FOR A IN ARGS:
TOTAL += INT(A)
PRINT("ARGUMENTS:", ARGS)
PRINT("TOTAL =", TOTAL)
PYTHON [Link] 10 20 30 40
ARGUMENTS: ['10', '20', '30', '40']
TOTAL = 100
EXAMPLE 4: CHECK IF THE USER PASSED
ENOUGH ARGUMENTS:
IMPORT SYS
IF LEN([Link]) < 3:
PRINT("ERROR: PLEASE PASS 2 NUMBERS!")
[Link]()
A = INT([Link][1])
B = INT([Link][2])
PRINT("PRODUCT =", A * B)
PYTHON [Link] 5
ERROR: PLEASE PASS 2 NUMBERS!
EXAMPLE 5: USING ARGPARSE
(PROFESSIONAL WAY):
• PYTHON PROVIDES A BETTER MODULE CALLED ARGPARSE FOR ADVANCED ARGUMENT HANDLING.
PROGRAM: [Link]
IMPORT ARGPARSE
PARSER = [Link](DESCRIPTION="DEMO OF ARGPARSE")
PARSER.ADD_ARGUMENT("NAME", HELP="YOUR NAME")
PARSER.ADD_ARGUMENT("AGE", TYPE=INT, HELP="YOUR AGE")
PARSER.ADD_ARGUMENT("-C", "--CITY", HELP="YOUR CITY", DEFAULT="UNKNOWN")
ARGS = PARSER.PARSE_ARGS()
PRINT("NAME:", [Link])
PRINT("AGE:", [Link])
PRINT("CITY:", [Link])
OUTPUTS:
• PYTHON [Link] KAVYA 22 --CITY HYDERABAD
• NAME: KAVYA
• AGE: 22
• CITY: HYDERABAD
*ARGS AND **KWARGS
• THEY ARE USED IN PYTHON FUNCTIONS TO ACCEPT A VARIABLE NUMBER OF ARGUMENTS.
1. *ARGS → MULTIPLE POSITIONAL ARGUMENTS
IT ALLOWS A FUNCTION TO RECEIVE ANY NUMBER OF VALUES.
ARGS BECOMES A TUPLE.
• EXAMPLE 1: SIMPLE *ARGS
DEF ADD(*ARGS):
PRINT(ARGS)
ADD(10, 20, 30)
OUTPUT:
• (10, 20, 30)
EXAMPLE 2: SUM ALL NUMBERS:
DEF TOTAL(*NUMS):
S=0
FOR N IN NUMS:
S += N
RETURN S
PRINT(TOTAL(5, 10, 15, 20))
• OUTPUT:50
2. **KWARGS → MULTIPLE KEYWORD ARGUMENTS
IT ALLOWS A FUNCTION TO RECEIVE ANY NUMBER OF
KEY=VALUE PAIRS.
KWARGS BECOMES A DICTIONARY.
EXAMPLE 1: PRINT KEYWORD ARGUMENTS
DEF DETAILS(**KWARGS):
PRINT(KWARGS)
DETAILS(NAME="KAVYA", AGE=22, COUNTRY="INDIA")
OUTPUT:
{'NAME': 'KAVYA', 'AGE': 22, 'COUNTRY': 'INDIA'}
EXAMPLE 2: ACCESS EACH KEY-VALUE
DEF SHOW_INFO(**INFO):
FOR KEY, VALUE IN [Link]():
PRINT(KEY, "=", VALUE)
SHOW_INFO(NAME="KAVYA", COURSE="MCA", SUBJECT="PYTHON")
• OUTPUT:
NAME = KAVYA
COURSE = MCA
SUBJECT = PYTHON
Difference Between args and kwargs
Feature *args **kwargs
Type tuple dictionary
unlimited positional unlimited key–value
Accepts
arguments arguments
Example input (10, 20, 30) {"name":"Kavya"}
CAN WE USE BOTH TOGETHER?
• DEF DEMO(*ARGS, **KWARGS):
PRINT("ARGS:", ARGS)
PRINT("KWARGS:", KWARGS)
DEMO(1, 2, 3, NAME="KAVYA", AGE=22)
OUTPUT:
ARGS: (1, 2, 3)
KWARGS: {'NAME': 'KAVYA', 'AGE': 22}
• RULE: CORRECT ORDER OF ARGUMENTS IN A PYTHON FUNCTION
• IN PYTHON, FUNCTION PARAMETERS MUST FOLLOW THIS ORDER:
• 1️⃣NORMAL (POSITIONAL) ARGUMENTS
2️⃣*ARGS
3️⃣KEYWORD-ONLY ARGUMENTS
4️⃣**KWARGS
• THE CORRECT SYNTAX LOOKS LIKE:
DEF FUNCTION(NORMAL, *ARGS, KEYWORD_ONLY, **KWARGS):
PASS
EXAMPLE:
• FULL EXAMPLE (MOST IMPORTANT!)
DEF DEMO(A, B, *ARGS, C, **KWARGS):
PRINT("A =", A)
PRINT("B =", B)
PRINT("ARGS =", ARGS)
PRINT("C =", C)
PRINT("KWARGS =", KWARGS)
FUNCATION CALL:DEMO(1, 2, 3, 4, 5, C=10, X=100, Y=200)
OUTPUT:A = 1
B=2
ARGS = (3, 4, 5)
C = 10
KWARGS = {'X': 100, 'Y': 200}
WHAT ARE UNPACKING OPERATORS?
PYTHON HAS TWO UNPACKING OPERATORS:
✔ * (SINGLE STAR) → UNPACKS ITERABLES (LIST, TUPLE, STRING)
✔ ** (DOUBLE STAR) → UNPACKS DICTIONARIES
THEY ARE USED TO EXPAND OR BREAK COLLECTIONS INTO INDIVIDUAL ELEMENTS.
• 1. * OPERATOR (UNPACKS ITERABLES)
EXAMPLE 1: UNPACKING A LIST
NUMBERS = [10, 20, 30]
PRINT(*NUMBERS)
OUTPUT:
10 20 30
• *NUMBERS EXPANDS THE LIST INTO THREE SEPARATE VALUES.
EXAMPLE 2: ASSIGNING USING *
A, *B = [1, 2, 3, 4, 5]
PRINT(A)
PRINT(B)
OUTPUT:
• 1
• [2, 3, 4, 5]
• A GETS THE FIRST VALUE
• B GETS THE REST OF THE LIST
EXAMPLE 3: MERGE LISTS USING *
LIST1 = [1, 2]
LIST2 = [3, 4]
MERGED = [*LIST1, *LIST2]
PRINT(MERGED)
OUTPUT:
• [1, 2, 3, 4]
EXAMPLE 4: PASSING MULTIPLE ARGUMENTS TO A FUNCTION
DEF ADD(A, B, C):
RETURN A + B + C
NUMS = [10, 20, 30]
PRINT(ADD(*NUMS))
OUTPUT:
• 60
• *NUMS BREAKS THE LIST INTO 3 VALUES → 10, 20, 30.
** OPERATOR (UNPACKS DICTIONARIES)
USED TO UNPACK KEY:VALUE PAIRS.
EXAMPLE 1: UNPACKING DICTIONARY
DETAILS = {"NAME": "KAVYA", "AGE": 22}
PRINT(**DETAILS) # ERROR IF PRINTED DIRECTLY
BUT IT WORKS IN FUNCTIONS:
DEF SHOW(NAME, AGE):
PRINT(NAME, AGE)
SHOW(**DETAILS)
OUTPUT:
• KAVYA 22
EXAMPLE 2: MERGE DICTIONARIES
D1 = {"A": 10, "B": 20}
D2 = {"C": 30, "D": 40}
MERGED = {**D1, **D2}
PRINT(MERGED)
OUTPUT:
• {'A': 10, 'B': 20, 'C': 30, 'D': 40}
EXAMPLE 3: OVERRIDE VALUE WHEN MERGING
D1 = {"A": 10, "B": 20}
D2 = {"B": 999, "C": 30}
PRINT({**D1, **D2})
OUTPUT:
• {'A': 10, 'B': 999, 'C': 30}
• D2 VALUES OVERRIDE D1.
3. USING * AND ** IN FUNCTION CALLS
FUNCTION WITH ARGS AND KWARGS:
DEF DEMO(*ARGS, **KWARGS):
PRINT(ARGS)
PRINT(KWARGS)
VALUES = [1, 2, 3]
INFO = {"NAME": "KAVYA", "AGE": 22}
DEMO(*VALUES, **INFO)
OUTPUT:
• (1, 2, 3)
• {'NAME': 'KAVYA', 'AGE': 22}