Avendo scritto e poi rifatto un pitone "God object", sono solidale. Quello che ho fatto è spezzare l'oggetto originale in sottosezioni basate su metodi. Ad esempio, l'originale assomigliava a questo pseudo codice:

method A():
    self.bla += 1

method B():
    self.bla += 1

do stuff():
    self.bla = 1
    method A()
    method B()
    print self.bla

Il metodo roba è una "unità" di lavoro autonoma. L'ho migrato verso una nuova classe che l'originale istanzia. Questo ha tirato fuori anche le proprietà necessarie. Alcuni erano usati solo dalla sottoclasse e potevano spostarsi dritto. Altri sono stati condivisi e sono stati spostati in una classe condivisa.

L'oggetto "Dio" crea una nuova copia della classe condivisa all'avvio e ciascuna delle nuove sottoclassi accetta un puntatore come parte del loro metodo init. Ad esempio, ecco una versione ridotta del mailer:

#!/usr/bin/env python
# -*- coding: ascii -*-
'''Functions for emailing with dirMon.'''

from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
import os
import smtplib
import datetime
import logging

class mailer:
    def __init__(self,SERVER="mail.server.com",FROM="[email protected]"):
        self.server = SERVER
        self.send_from = FROM
        self.logger = logging.getLogger('dirMon.mailer')

    def send_mail(self, send_to, subject, text, files=[]):
        assert type(send_to)==list
        assert type(files)==list
        if self.logger.isEnabledFor(logging.DEBUG):
            self.logger.debug(' '.join(("Sending email to:",' '.join(send_to))))
            self.logger.debug(' '.join(("Subject:",subject)))
            self.logger.debug(' '.join(("Text:",text)))
            self.logger.debug(' '.join(("Files:",' '.join(files))))
        msg = MIMEMultipart()
        msg['From'] = self.send_from
        msg['To'] = COMMASPACE.join(send_to)
        msg['Date'] = formatdate(localtime=True)
        msg['Subject'] = subject
        msg.attach( MIMEText(text) )
        for f in files:
            part = MIMEBase('application', "octet-stream")
            part.set_payload( open(f,"rb").read() )
            Encoders.encode_base64(part)
            part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
            msg.attach(part)
        smtp = smtplib.SMTP(self.server)
        mydict = smtp.sendmail(self.send_from, send_to, msg.as_string())
        if self.logger.isEnabledFor(logging.DEBUG):
            self.logger.debug("Email Successfully Sent!")
        smtp.close()
        return mydict

Viene creato una volta e condiviso tra le diverse classi che richiedono funzionalità di mailing.

Quindi per te, crea una classe larry con le proprietà e i metodi di cui hai bisogno. Ovunque il cliente dice larry = blah sostituirlo con larryObj.larry = blah . Questo migra le cose in sottoprogetti senza rompere l'interfaccia corrente.

L'unica altra cosa da fare è cercare "unità di lavoro". Se stavi per trasformare parte del "God Object" nel suo metodo, fai così . Ma, metti il metodo all'esterno . Questo ti obbliga a creare un'interfaccia tra i componenti.

Porre queste basi permette a tutto il resto di seguirlo. Ad esempio, un pezzo dell'oggetto helper che mostra come si interfaccia con il mailer:

#!/usr/bin/env python
'''This module holds a class to spawn various subprocesses'''
import logging, os, subprocess, time, dateAdditionLib, datetime, re

class spawner:
    def __init__(self, mailer):
        self.logger = logging.getLogger('dirMon.spawner')
        self.myMailer = mailer

Concentrati sulla più piccola unità di lavoro possibile e spostala. Questo è più facile da fare e ti consente di giocare velocemente con l'installazione. Non guardare le proprietà di oggetti in movimento, sono accessorie ai compiti che vengono eseguiti con loro nella maggior parte dei casi. Qualunque cosa rimanga dopo aver trattato i metodi dovrebbe probabilmente rimanere nell'oggetto originale, poiché fa parte dello stato condiviso.

Ma , i nuovi oggetti dovrebbero ora accettare le proprietà di cui hanno bisogno come variabili init, non toccando la proprietà dell'oggetto chiamante. Quindi restituiscono tutti i valori necessari, che possono essere utilizzati dal chiamante per aggiornare le proprietà condivise in base alle esigenze. Questo aiuta a disaccoppiare gli oggetti e crea un sistema più robusto.