Простой Язык Переводчик


Я играл вокруг с Python и о прошлом году, а совсем недавно придумали следующие 68 (был 62) линии. Я думаю, что я попробую сделать калькулятор из него. Я бы очень хотел знать, что читатели думают о своих атрибутов, таких как стиль написания, читабельность, и целесообразно целеустремленность.

# notes: separate addresses from data lest the loop of doom cometh

class Interpreter:

  def __init__(self):
    self.memory = { }
    self.dictionary = {"mov" : self.mov,
                       "put" : self.put,
                       "add" : self.add,
                       "sub" : self.sub,
                       "clr" : self.clr,
                       "cpy" : self.cpy,
                       "ref" : self.ref }
    self.hooks = {self.val("0") : self.out }

  def interpret(self, line):
    x = line.split(" ")
    vals = tuple(self.val(y) for y in x[1:])
    dereferenced = []
    keys_only = tuple(key for key in self.memory)
    for val in vals:
      while val in self.memory: val = self.memory[val]
      dereferenced.append(val)
    vals = tuple(y for y in dereferenced)
    self.dictionary[x[0]](vals)

  def val(self, x):
    return tuple(int(y) for y in str(x).split("."))

  def mov(self, value):
    self.ptr = value[0]

  def put(self, value):
    self.memory[self.ptr] = value[0]

  def clr(self, value):
    if self.ptr in self.hooks and self.ptr in self.memory:
      x = self.hooks[self.ptr]
      y = self.memory[self.ptr]
      for z in y: x(z)
    del self.memory[self.ptr]

  def add(self, values):
    self.put(self.mat(values, lambda x, y: x + y))

  def sub(self, values):
    self.put(self.mat(values, lambda x, y: x - y))

  def mat(self, values, op):
    a, b = self.memory[values[0]], self.memory[values[1]]
    if len(a) > len(b): a, b = b, a
    c = [op(a[x], b[x]) for x in xrange(len(b))] + [x for x in a[len(a):]]
    return [tuple(x for x in c)]

  def cpy(self, value):
    self.put(value)

  def out(self, x):
    print chr(x),

  def ref(self, x):
    self.put(x)

interp = Interpreter()
for x in file(__file__.split('/')[-1].split(".")[-2] + ".why"):
  interp.interpret(x.strip())


572
6
задан 17 июня 2011 в 05:06 Источник Поделиться
Комментарии
2 ответа

Чтобы ваш модуль загрузки других файлов, это обычно пишут в конце его , если __имя__ == '__главный__': условно вот так:

if __name__ == '__main__':
interp = Interpreter()
for x in file(__file__.split('/')[-1].split(".")[-2] + ".why"):
interp.interpret(x.strip())

Может, я привередничаю (но вы просили стиль ввода), почитать PEP8 и стараться его придерживаться как можно лучше (стенд). Одна вещь, которая бросилась мне в глаза сразу же был ваш 2 место вмятины и PEP8 рекомендации 4. Одна переменные письмо обычно рекомендуются только для лупинга Варс. Вы, вероятно, может повысить удобочитаемость кода, переименовав некоторые из этих Х, Y, В и т. д.

Другой принцип программирования Python является использование предоставленных инструментов, я размышлял, что ты делал с:

__file__.split('/')[-1].split(".")[-2] + ".why"

альтернатива, которая использует существующие модули Python (и более портативных платформ) является:

os.path.splitext(os.path.basename(__file__))[0] + ".why"

Это примерно такой же длины, и это намного более понятно, что вы делаете, как имена функций заклинание.

3
ответ дан 17 июня 2011 в 02:06 Источник Поделиться

Извините за резкость, намеренно или нет, но здесь мы идем!

Не очень хорошая читаемость ИМО. Это займет некоторое время, чтобы понять, что код делает. Модульные тесты или, по крайней мере, пример входных и выходных данных может сделать это очевидным.

В общем, именования должны быть улучшены. Трудно понять, что функция или переменная от своего имени.

Есть также много перетасовки данных и обратно, что кажется ненужным. Похоже, это может быть упрощенный совсем немного, увидеть встроенных комментариев.

Также можно использовать кортежи во многих ситуациях, когда список будет более естественным.

Как я имел проблемы с пониманием кода, я может не понял чего в ней, так что читайте следующие встроенные комментарии с учетом.

# notes: separate addresses from data lest the loop of doom cometh

Не очень полезный комментарий, Да?

class Interpreter:

Вы можете найти имя класса, который лучше говорит, что этот класс делает? Он не только интерпретирует.

  def __init__(self):
self.memory = { }

Я бы хотел прокомментировать то, что самостоятельно.памяти.

    self.dictionary = {"mov" : self.mov,
"put" : self.put,
"add" : self.add,
"sub" : self.sub,
"clr" : self.clr,
"cpy" : self.cpy,
"ref" : self.ref }

Ни хрена, это словарь. Но вы можете найти имя, которое говорит о каком словаре?

Чтобы уменьшить размер кода, Вы можете считать себя.словарь = дикт(самовыдвижение.функцией getattr(АТР) для attr в мову добавить суб среды CLR CPY по реф'.Сплит()), но некоторые люди могут найти его слишком "умный".

    self.hooks = {self.val("0") : self.out }

Очень непонятно, что крючки для. Это единственная ценность, которая каждое положить в него. самовывоз.функция val("0") кажется просто сложный способ сказать, что (0,). Что это такое?

  def interpret(self, line):
x = line.split(" ")

Плохое имя переменной: х. Это должно быть жетонов вместо?

    vals = tuple(self.val(y) for y in x[1:])

Здесь, вальс может быть список, а не, как вальс = [собственной личности.функция val(Y) для Y в Х[1:]]. Что делает его кортеж просто делает код немного сложнее без причины.

    dereferenced = []
keys_only = tuple(key for key in self.memory)

Рассмотрим keys_only = собственн.памяти.ключи()? Да, и кстати, keys_only никогда не используется, так что просто удалить его.

    for val in vals:
while val in self.memory: val = self.memory[val]

Похоже, что этот цикл будет бесконечным, если он работает на всех. Это должно быть если?

      dereferenced.append(val)
vals = tuple(y for y in dereferenced)

Бессмысленно преобразования разыменован для кортежа.

    self.dictionary[x[0]](vals)

Я думаю, что весь интерпретировать метод может быть переписан на что-то вроде следующего. Обратите внимание на измененные имена.

  def interpret(self, line):
command, *tokens = line.split() # Python 3 only
values = [self.val(y) for token in tokens]
dereferenced = [self.memory.get(value, value) for value in values]
self.dictionary[command](dereferenced)

Некоторые могут сказать, что это немного слишком немногословны. Я мог бы написать в разыменован = ... линии в несколько более явном возможно.

Я не буду вдаваться в остальные, но комментарии о наименовании и ненужные сложности применяется.

10
ответ дан 17 июня 2011 в 10:06 Источник Поделиться