Det allra mest "korrekta" är troligen att skapa en gemensam konfigurationsfil som läses med `ConfigParser`. Läsningen av denna fil skulle dock smidigt kunna hanteras i en modul.
Du får då en "plaintext"-konfigurationsfil som är enkelt redigerbar, och du måste inte importera variablerna globalt, vilket inte är trevlig praxis (och rent utav problematiskt i vissa fall).
Ett minimalt exempel:
Konfigurationsfil (här lagd i "C:\filer\config"; se dokumentation för ConfigParser för att se vilket format konfigurationsfiler har):
[GOM]
username = nrj
output = C:\filer\output
Modul (namn `GOMConfig.py` någonstans där ditt Pythonprogram hittar den — kolla upp hur man importerar moduler):
import ConfigParser
def get_config():
config_path = 'C:\filer\config'
config = ConfigParser.SafeConfigParser()
config.read(config_path)
return dict(config.items('GOM'))
Program:
import GOMConfig
def main():
c = GOMConfig.get_config()
print 'Hej, du heter {} och din utfil bor i "{}".'.format(
c['username'], c['output'])
if __name__ == '__main__':
main()
Detta skulle vid körning av programmet ge output:
Hej, du heter nrj och din utfil bor i "C:\filer\output".
Jag antog här att alla konfigureringsalternativ har en enkel "key:value"-struktur så att `dict()` fungerar. Lösningen är enkelt utbyggbar. Ska det in mycket logik så är det nog smidigast att göra en klass av det hela, men det kan nog vara overkill här. Det finns utrymme att ändra exakt hur konfigurationsalternativen ska passas till det nya programmet; en dictionary är bara en av möjligheterna.
För att svara på din sista fråga så behöver en modul bara ha läsrättigheter för att fungera.
Att läsa in en rå fil och köra `exec()` på innehållet är måhända en oneliner, men det är i ärlighetens namn inte speciellt snyggt eller rekommenderat för en hållbar lösning. Dels är det ett massivt säkerhetshål (men er hotbild är nog inte så stor), och dels så finns det andra problem med felhantering som bättre löses av de färdiga modulerna för att läsa just konfigurationsfiler.
