[Note: It's a bit late, don't hesitate if there's things that I'll not explain clearly]
If I understand right, your main issue is the too many arguments when creating an object.
But thankfully, there's ways to solve this issue.
Your arguments are all positional (what variable get what value depend on the position of the value). It's useful when you've a short list of arguments, but as you witnessed, it become a problem when the list grow.
To counter this, prefer named/keyword arguments (a couple name/value) every time it make sense.
Positional argument declaration:
def __init__( argument1, argument2, argument3 )
Positional argument use:
var = MyClass( value1, value2, value3
Named argument declaration:
def __init__( argument1=defaultValue1, argument2=defaultValue2, argument3=defaultValue3 )
Named argument use:
var = MyClass( argument2=value2, argument1=value1, argument3=value3 )
As you can see, each name argument have a default value. If an argument do not get an explicit value when the function/method is called, then it will get that default value.
Python:
init python:
def testFnct( arg1=None, arg2="Default" ):
print( "arg1 is " + str( arg1 ) )
print( "arg2 is " + str( arg2 ) )
If you use the console to call that function,
testFnct( 1, 2 ) will print:
Side note: Note that when the position of the value match the position of the argument, you can make them works like positional argument. But I do not recommend to do it, because it's more confusing that helping. I did it only for the demonstration.
but
testFnct( arg2="Changed" ) will print:
and
testFnct() will print:
For each one of your arguments, there's surely a value that is (or will be) used often. It's its default value.
That way, each time an object have to assign that value, you can just skip it. This will shorten a bit the call.
The other advantage when using named argument is precisely it's readability. Especially when you keep in mind that you can perfectly split a line.
Let's say that your __init__ declaration only use named arguments, you can perfectly have this:
Python:
var = government( name = "Evil ones",
glevel = "town",
corruption = 100,
influence = 50
prestige = 10
base = { ... }
mod = {...}
policies = [ "unique party", "curfew" ],
upgrades = [ ... ] )
What is perfectly manageable by a human.
Now, this being said, generally declarations use a mix between positional and named arguments. The first ones being used for any value expected to be unique for an object, while the second ones are used for anything that tweak the object.
So, in your case, it would looks like:
def __init__( self, name, glevel="town", corruption=50, influence=50, prestige=50, [...] )
Now, another thing that you can use, is dictionary unpacking.
When you've something like
myDict = { "a": 1, "b": 2, "c": 3 } you can turn it into a suit of named arguments through the use of
**.
In your class, there's three arguments that will probably have common values shared between many governments: "corruption", "influence" and "prestige".
So, you can have generic description for them:
Python:
averageDemocracy = { "corruption": 30, "influence": 50, "prestige": 50 }
averageDictatorship = { "corruption": 90, "influence": 30, "prestige": 30 }
Then you can simplify a bit more the creation of an object:
Python:
var = government( "Evil ones", # Name is a positional argument.
#glevel = "town", # "town" is the default value, you can skip it.
base = { ... },
mod = { ... },
policies = [ "unique party", "curfew" ],
upgrades = [ ... ],
# Finally add /corruption/, /influence/ and /prestige/ values
# as they are defined by the /averageDictatorship/ dict.
**averageDictatorship )
Finally, in your example, I would also use a "false default value" approach for your two dictionaries arguments:
Python:
def __init__( [...] ):
[...]
# Not everything can be defaulted.
if not "population" in base: raise ValueError( "You MUST define at least a base population value" )
# I used 0 as default value, but you can obviously use whatever you want.
if not "previousAS" in base: base["previousAS"] = 0
if not "previousAW" in base: base["previousAW"] = 0
if not "previousDS" in base: base["previousDS"] = 0
if not "edugrant" in base: base["edugrant"] = 0
# You can even make a default value depend on another value, passed or defaulted.
if not "churchgrant" in base: base["churchgrant"] = int( base["polulation"] / 2 )
if not "otherexpenses" in base: base["otherexpenses"] = 0
This would also permit to simplify your declaration.
In the end, your example would now looks like:
Python:
init python:
class government:
def __init__(self, name, glevel="town", corruption=10, influence=50, prestige=50, base={}, mod={}, policies=[], upgrades=[]):
[...]
# There's possibility of conflict between /define/ and /default/, so create this in the /init/ block.
# Being declared here and not changed, it shouldn't be part of savable values.
badNeighborhoodDemocracy = { "corruption": 0, "influence": 0, "prestige": -1000.0 }
default town = government( 'Virgin Bay',
base = { "population": 9999, "otherexpenses": 25.01 },
mod = { [...] }, # I haven't made example for the default values
**badNeighborhoodDemocracy )
What is way simpler than what you have actually and don't need that you rely on an external file for the definition.
Side note:
Relying on an external file wouldn't effectively solve your issue, because it isn't effectively more readable. You just moved the issue, passing from:
Python:
default town = government( 'Virgin Bay',
'town',
0,
0,
-1000.0,
{'population':9999, 'previousAS':0, 'previousAW':0, 'previousDS':0, 'edugrant':0, 'churchgrant':5000, 'otherexpenses':25.01},
{'population':1.0004, 'poptax':0.04, 'bsnstax':0.025, 'edutax':0.05, 'churchtax':0.00, 'churches':['protestant','catholic','nondiscript']},
[],
[] )
to something that would looks the same in the file, but would have to be imported in a way or another.
Would you be able, in few months, to tell that the first "0" is the corruption, and the second the "influence" without having to look back at the "__init__()" declaration ?
