Was ist der richtige Weg, um Klasse, Objekt in Python zu konstruieren

Question

Wenn ich mehrere Klasse wie Klasse Page, Klasse Page1, Klasse Page2, die die gleiche Element-Klasse verwenden müssen. Um den self.driver für die ELement-Klasse zu verwenden, muss ich viel Code von class Ele(e) bis class itemWrap auf jedem class Page kopieren, um self.driver als Eingabe zu übergeben. Was ist der beste Weg für mich, den folgenden Code zu erstellen?

# elements.py 
class Element(object): 

    def addItem(self, owner=None): 
     for _i in owner: 
      options = self.findAvaItem() 
      i = options.index(_i) 
      self.ele.find_element_by_xpath('{}/{}'.format(self.l, i)).click() 

    def delItem(self, owner=None): 
     for _i in owner: 
      options = self.findSelecItem() 
      i = options.index(_i) 
      self.ele.find_element_by_xpath('{}/{}'.format(self.l, i)).click() 

    def findAvaItem(self): 
     _o = self.driver.find_element_by_css_selector('css==div.menu.transition.visible').text 
     return _o.split('\n') 

    def findSelecItem(self): 
     _o = self.driver.find_element_by_css_selector('css==a.ui.label') 
     return [i.text for i in _o] 

# BasePage.py 
class BasePage(object): 

    def __init__(self, driver): 
     self.driver = driver 

# Page.py 
from elements import Element as e 

class Ele(e): 
    def __init__(self, driver, _t): 
     self.driver = driver 
     self.l = 'element l variable' 
     self.t = _t 

class itemWrap(object): 

    def __init__(self, driver, _type): 
     self.ele = Ele(driver, _type) 
     self.driver = driver 
     self.t = _type 

    def sel_item(self, _value): 
     self.ele.addItem(_value) 

    def desel_item(self, _value): 
     self.ele.delItem(_value) 

class Page(BasePage): 
    def inputItem(self, _type, _value): 
     itemWrap(self.driver, _type).sel_item(_value) 

    def removeItem(self, _type, _value): 
     itemWrap(self.driver, _type).desel_item(_value) 

# Test.py 
from Page import Page 
from selenium import webdriver as WebDriver 

class Test(object): 

    @classmethod 
    def setup_class(cls): 
     if hasattr(super(Test, cls), 'setup_class'): 
      super(Test, cls).setup_class() 
     cls.driver = WebDriver(desired_capabilities=chrome, command_executor='127.0.0.1') 

    def check_function(self): 
     self.Page.inputItem('typeA', ['item A1', 'item A2', 'item A3']) 
     self.Page.removeItem('typeA', ['item A1', 'item A2', 'item A3']) 
     self.Page.inputItem('typeB', ['item B1', 'item B2']) 
     self.Page.removeItem('typeB', ['item B1', 'item B2']) 

Answer 1

Es scheint, wie Sie versuchen, eine Fassadenschicht in Ihrer itemWrap Klasse zu bauen, so dass jede Methode der itemWrap geht nur entlang einem Aufruf self.ele. Ist das richtig?

Wenn ja, können Sie die Funktionen im laufenden Betrieb generieren. (Sie könnten mehr tun, automatisiertes Zeug, wenn es ein konsistentes Textmuster in den Wrap-Verfahren gegen Element-Methode Namen ist. Wie ist, erhalten Sie eine dict zu bieten haben.)

class Ele: 
    def addItem(self, x): 
     print("Additem",x) 
    def delItem(self, x): 
     print("DelItem",x) 

class ItemWrap: 
    def __init__(self, ele): 
     self.ele = ele 

    method_map = { 
     'sel_item': 'addItem', 
     'desel_item': 'delItem', 
     # more methods go here 
    } 

for myname, elname in ItemWrap.method_map.items(): 
    msrc = "def {}(self, _value):\n" \ 
      " return self.ele.{}(_value)\n".format(myname, elname) 
    gbls = {} 
    exec(msrc, gbls) 
    setattr(ItemWrap, myname, gbls[myname]) 

e = Ele() 
i = ItemWrap(e) 
i.sel_item(10) 
i.desel_item(11)