Question

我有一个我最初留下的脚本作为一个长函数。

#! /usr/bin/env python
import mechanize
from BeautifulSoup import BeautifulSoup
import sys
import sqlite3

def dictionary(word):
    br = mechanize.Browser()
    response = br.open('http://www.dictionary.reference.com')
    br.select_form(nr=0)
    br.form['q'] = word 
    br.submit()
    definition = BeautifulSoup(br.response().read())
    trans = definition.findAll('td',{'class':'td3n2'})
    fin = [i.text for i in trans]
    query = {}
    word_count = 1
    def_count = 1
    for i in fin: 
        query[fin.index(i)] = i
    con = sqlite3.connect('/home/oberon/vocab_database/vocab.db')
    with con:
        spot = con.cursor()
        spot.execute("SELECT * FROM Words")
        rows = spot.fetchall()
        for row in rows:
            word_count += 1
        spot.execute("INSERT INTO Words VALUES(?,?)", (word_count,word))
        spot.execute("SELECT * FROM Definitions")
        rows = spot.fetchall()
        for row in rows:
            def_count += 1
        for q in query:
            spot.execute("INSERT INTO Definitions VALUES(?,?,?)", (def_count,query[q],word_count))
            def_count += 1
    return query

print dictionary(sys.argv[1])

现在，我想通过创建一个类来练习OOP表单。我认为最好将其分成至少几个功能。

我想出了：

#! /usr/bin/env python
import mechanize
from BeautifulSoup import BeautifulSoup
import sys
import sqlite3


class Vocab:
    def __init__(self):
        self.word_count = 1
        self.word = sys.argv[1] 
        self.def_count = 1
        self.query = {}

    def dictionary(self,word):
        self.br = mechanize.Browser()
        self.response = self.br.open('http://www.dictionary.reference.com')
        self.br.select_form(nr=0)
        self.br.form['q'] = word 
        self.br.submit()
        self.definition = BeautifulSoup(self.br.response().read())
        self.trans = self.definition.findAll('td',{'class':'td3n2'})
        self.fin = [i.text for i in self.trans]
        for i in self.fin: 
            self.query[self.fin.index(i)] = i
        return self.query

    def word_database(self):
        self.con = sqlite3.connect('/home/oberon/vocab_database/vocab.db')
        with self.con:
            self.spot = self.con.cursor()
            self.spot.execute("SELECT * FROM Words")
            self.rows = self.spot.fetchall()
            for row in self.rows:
                self.word_count += 1
            self.spot.execute("INSERT INTO Words VALUES(?,?)", (self.word_count,self.word))
            self.spot.execute("SELECT * FROM Definitions")
            self.rows = self.spot.fetchall()
            for row in self.rows:
                self.def_count += 1
            for q in self.query:
                self.spot.execute("INSERT INTO Definitions VALUES(?,?,?)", (self.def_count,self.query[q],self.word_count))
                self.def_count += 1



Vocab().dictionary(sys.argv[1])

我知道在最后一行，当我打电话给 Vocab（）。字典（sys.argv [1]）时，这只会运行字典方法。我每次运行脚本时都试图弄清楚如何调用 word_database 方法。

这是错误的方法吗？我应该把这些方法只留下一个大方法吗？

Answer 1

它对我来说看起来很好。唯一真正的问题是你做什么

for row in rows:
        word_count += 1

而不是

word_count += len(rows)

至于你的问题，你可以通过

来调用word_database

self.word_database()

Answer 2

我不确定它是一个类是否有任何优势，但如果你想调用一个实例的多个方法，你需要为该实例指定一个名称。

vocab = Vocab()
vocab.dictionary(...)
vocab.word_database(...)

Answer 3

您只需要在原始脚本中的相同位置调用word_database。

def dictionary(self,word):
    self.br = mechanize.Browser()
    self.response = self.br.open('http://www.dictionary.reference.com')
    self.br.select_form(nr=0)
    self.br.form['q'] = word 
    self.br.submit()
    self.definition = BeautifulSoup(self.br.response().read())
    self.trans = self.definition.findAll('td',{'class':'td3n2'})
    self.fin = [i.text for i in self.trans]
    for i in self.fin: 
        self.query[self.fin.index(i)] = i

    # Continue the script...
    self.word_database()

    return self.query

Answer 4

有几件事：

首先，您不需要将所有变量设为self.var_name，因为您将它们包装在类中。如果函数调用完成后不需要变量，只需使用局部变量。

其次，每次Vocab使用字典将self.word_database（）添加到init函数__init__(self, word)时，都要调用word_database。这将确保这些功能始终可用。

第三，如果你只是将对象视为一个脚本并且做Vocab（）。字典（word）你可能最好不要使用类结构。如果你计划用Vocab（）计算一些工作，然后逐步做其他工作（重复调用字典），那么保持类结构。但是你目前使用它的方式就像一个函数调用。（如果保留函数调用语义，至少应该将原始函数分解为更小的部分。）

Answer 5

我建议首先进行重构而不要面向对象。你没有通过上课获得任何东西。只需定义两种方法，最后：

dictionary(sys.argv[1)
word_database()

使用python类方法

5 个答案: