python manage variables across project level

[mg24]

Hi Team,

how to manage variables which can be used in project level, instead of passing all variables from main def

In my project I am using total 10 modules. [no class module used]

in main function I have created all variables.
few functions are calling in same module, and passing 80% job to another module. main2 to finish.

from main_function I am passing all variables to main2 function which is in another module
and importing all functions from other module into main2 module.
and doing jobs.

import sys
import json

def main():    
    var1 =   sys.argv[1]
    var2  =   sys.argv[2]
    var3  =   sys.argv[3]
    var4  =   sys.argv[4]
    var5  =   sys.argv[5]

    with open("DBConfig.json","r") as myconfig:        
        obj = json.loads(myconfig)
        
        server = obj[1]
        database = obj[2]
        constant_path = obj[3]
        logging_path = obj[4]
        
        hd ,conn = connect_database(server,database)
        hd, conn = connect_SP(server, database,logger)
        
        #function call with
        main2(var1,var2,var3,var4,var5,var6,server,database,constant_path,conn,logging_path)
            pass
        
if "___name__ " == "__main__":
    main()

[deanhystad]

This is ugly.
To start with, you should never have this many positional arguments in a function. I try to limit positional arguments to 1, maybe 2. I only use positional arguments if they make sense for the function, like list.append(item). For something like this I probably wouldn't have any positional arguments. Use named arguments instead.

meaningfully_named_function(
    your_name=sys.argv[1],   # Named arguments are self documenting
    your_quest=sys.argv[2],
    favorite_color=sys.argv[3],
    capitol_of_assyria=sys.argv[4],
    server=json_data["server"],
    database = json_data["database"],
    logging_path=json_data["logging_path")

5 positional command line arguments is a lot. Unless this is always called from a script or by another program it is going to be difficult for your user to get the order of the arguments right. You can use something like argparse to help with that. It can also help you keep the arguments straight inside your program.

The json file looks like it might be ugly too. This code makes it look like your json file should be a dictionary, not a list.

        server = obj[1]
        database = obj[2]  # key = "database"
        constant_path = obj[3]  # key = "constant_path"
        logging_path = obj[4]

Json files are not pretty, but they are human readable and editable. Instead of just containing a list of strings, your json file should have key:value pairs. The keys act like sign posts when reading the file. You don't have to remember the order of the fields because the fields all have names.

Here's an example I put together that uses argparse and reads a json file that contains a dictionary. This is the json file:

Output:
{
    "name":"John Lithgow",
    "address":"Third rock from the sun"
}

This is the program:

import argparse
import json

def do_math(operands, operator):
    """Something to receive operands and operator arguments"""
    if len(operands) < 2:
        print(operands[0], operator)
    else:
        print(operands[0], operator, operands[1])


def dump_json(filename):
    """Something to receive optional json file argument"""
    with open(filename, "r") as file:
        info = json.load(file)
    print(info["name"])
    print(info["address"])


# Configure the argument parser
parser = argparse.ArgumentParser()
parser.add_argument("operands", type=int, nargs="+", help="Operand(s).  1 or 2 depending on operator")
parser.add_argument("operator", type=str, help="Operator applied to operand(s)")
parser.add_argument("--json", type=str, required=False, help="json file with extra parameters")

# Parse the arguments.  Call the functions
args = parser.parse_args()
do_math(args.operands, args.operator)
if args.json:
    dump_json(args.json)

I can use -h or --help to ask the program for help with the command line arguments.

Output:
>>> python test.py -h
usage: test.py [-h] [--json JSON] operands [operands ...] operator

positional arguments:
  operands     Operand(s). 1 or 2 depending on operator
  operator     Operator applied to operand(s)

optional arguments:
  -h, --help   show this help message and exit
  --json JSON  json file with extra parameters

Now that I know the arguments I can run it for real.:

Output:
>>> python test.py --json stuff.json 1 2 +
1 + 2
John Lithgow
Third rock from the sun