Przejście z małych skryptów do większych aplikacji nie jest łatwe

Question

Uważam, że czytelność i zasada KISS są najważniejszymi czynnikami w programowaniu. Dlatego używam Python :)
A oto dokładny sytuacja, którą spotykamy się bardzo często:

powiedzieć, że mają ładny i czysty skrypt, który jest opakowaniem do obsługi bazy danych:

import database_schema as schema 
loader = schema.Loader("sqlite:///var/database.db") 
session = loader.session 

def addUser(name, full_name, password): 
    user = schema.User(name, full_name, password) 
    session.add(user) 
    session.commit() 

def listUsers(): 
    all_users = session.query(schema.User).all() 
    return all_users 

który jest używany tak:

import database 
database.addUser("mike", "Mike Driscoll", "password") 
database.listUsers() 

w pewnym momencie chcę przepisać ten moduł, tak aby mógł on pracować z bazami danych na inną ścieżkę (dla testów jednostkowych, na przykład).

Jakie są więc moje opcje?

1. Najbardziej intuicyjną rzeczą jest dodanie zmiennej database_path == "", a następnie ... co? Ustawienie go za pomocą funkcji setPath(new_path), a następnie dodanie wyjątku (if database_path == "": raise SomeException) do każdej funkcji, jest po prostu brzydkie i nie powinno być wykonywane przez nikogo.

2. W pełni funkcjonalna klasa z ustawianiem self._database_path w czasie inicjalizacji.

który jest następnie używany w ten sposób:

from database import Database 
database = Database("sqlite:///var/database.db") 
database.addUser("mike", "Mike Driscoll", "password") 
database.listUsers() 

To już kolejne linie kodu niż w pierwszym przykładzie, i dodanie problemu nazewnictwa: posiadanie klasy o nazwie Database w module database jest głupi, nie?

przepraszam za długi czytać, tutaj moje ostatnie pytania:

1. Dlaczego nie ma czegoś takiego jak __init__ funkcje modułów, w Pythonie?
2. Czy brakuje mi czegoś (statyczne zmienne klasy itp.), Które może zrobić to, co chcę (stały zbiór w czasie importu) w łatwy i czysty sposób, który wciąż nie jest daleko od modułu z wieloma prostymi funkcje, które były na początku?

P.S. przepraszam za mój angielski.

Edit:

Tak, aby to jasne, jak ten kod może wyglądać w mojej wyobraźni wszechświata Python:

import database_schema as schema 

def __init__(database_path): 
    loader = schema.Loader(database_path) 
    global session 
    session = loader.session 

def addUser(name, full_name, password): 
    user = schema.User(name, full_name, password) 
    session.add(user) 
    session.commit() 

def listUsers(): 
    all_users = session.query(schema.User).all() 
    return all_users 

i używane tak:

import database("sqlite:///var/database.db") 

database.addUser("mike", "Mike Driscoll", "password") 
database.listUsers() 

Answer 1

Moduł to obiekt w języku Python z arbitralnie nazwanymi atrybutami, które można powiązać i odwoływać się. Kod Pythona dla modułu o nazwie mod zwykle znajduje się w pliku o nazwie mod.py. Podczas próby zaimportowania tworzony jest nowy obszar nazw zawierający wszystkie atrybuty tego modułu.

Mimo wszystko, co powiedziane, nie jest to to samo, co klasa i tworzenie instancji obiektów tej klasy. Są to różne abstrakcje i powinny być używane jako takie.

zamiast testów na

if database_path == "": 
    .... 

zrobić pythonic sposób

if database_path: 
    .... 

I zamiast podniesienia wyjątek, można użyć dochodzić

assert database_path != "", 'database path empty' 

Moduł robi nie istnieją w smakach takich jak instancje obiektów klasy. Importowanie modułu spowoduje utworzenie przestrzeni nazw o tym samym zestawie atrybutów za każdym razem, gdy zostanie zaimportowany. W takiej sytuacji init może nie mieć większego sensu.

Nie ma nic złego w drugiej formie kodu, który podałeś. a jeśli nie chce tego robić im niektóre z powyższych idiomów może złagodzić ból :)

Answer 2

Jedynym rozwiązaniem, które znalazłem to, aby załadować konfigurację z pliku:

import ConfigParser 
config = ConfigParser.RawConfigParser() 
config.read('config.ini') 

def getSession(): 
    loader = schema.Loader(config.get('Global', 'database')) 
    return(loader.session) 
... 

Która jest not perfect: nazwa samego pliku jest zakodowana na stałe, a jeśli chcesz wykonać testy jednostkowe na innej (na przykład pustej) bazie danych, musisz zmienić przypisanie konfiguracji, a następnie przywrócić ją z powrotem, gdy skończysz, niezbyt elegancko.

Answer 3

W tego typu sytuacjach używam opcjonalnego parametru.

def addUser(name, full_name, password, _loader=None): 
    user = schema.User(name, full_name, password) 
    if (_loader is None): 
     # Use global values. 
     session.add(user) 
     session.commit() 
    else: 
     _session = _loader.session 
     # ... 

Ja sam, z dala od inicjowania takich rzeczy podczas ładowania modułu. Wyobraź sobie, że chcesz utworzyć dokumentację za pomocą narzędzi takich jak epydoc. W tym kontekście nie ma sensu tworzenie połączenia tylko dlatego, że ładuje moduł. Na pewno pójdę z podejściem klasowym.