| HN Mirror

First up let me apologise for the abrasive and somewhat unpleasant reply I gave to you. Not my best, sorry.

Ok, couldn't find a sample on the web so here's mine. It's not right for brevity and because this is the first python code I've done in ~3 years, so any criticisms welcome. Hopefully can get the formatting right

  # super.init omitted for brevity
  class Expession: # abstract base class
      def eval(): pass

  class Literal(Expession):
      def __init__(self, val): self.value = val        
      def eval(self): return self.value

  lit1 = Literal(8)
  print(lit1.eval()) # prints 8

  class UnaryExpr(Expession): pass # base class for unary expressions

  class Negate(UnaryExpr):
      def __init__(self, expr): self.expression = expr
      def eval(self): return - self.expression.eval()

  lit2 = Literal(13)
  neg = Negate(lit2)
  print(neg.eval()) # prints -13

  class BinaryExpression: pass # base class for binary expressions

  # Note that subclasses Add and Multiply have the same
  # __init__ code so I should hoist that into the BinaryExpression
  # base class but for clarity I'm leaving it in the subclasses

  class Add(BinaryExpression):
      def __init__(self, leftExpr, rightExpr):
          self.leftExpression = leftExpr
          self.rightExpression = rightExpr
      def eval(self):
          return self.leftExpression.eval() + self.rightExpression.eval()

  add2literals = Add(lit1, lit2) # 8 + 13
  print(add2literals.eval()) # prints 21

  class Multiply(BinaryExpression):
      def __init__(self, leftExpr, rightExpr):
          self.leftExpression = leftExpr
          self.rightExpression = rightExpr
      def eval(self): return self.leftExpression.eval() * self.rightExpression.eval()

  mult2literals = Multiply(lit1, lit2) # 8 * 13
  print(mult2literals.eval()) # prints 104

  # now let's make a complex expression, say (7 + 2) * (-4)
  # Doing this by hand but a parser would build this from that
  # string
  expr = Multiply(
      Add(Literal(7), Literal(2))
      ,
      Negate(Literal(4)))
  print(expr.eval()) # prints -36

Basically it's a tree of objects that you call eval() on the root, and these recursively call eval down, then when they reach the bottom start returning their subtree-calculated values.

Make sense?

Re. the left join, I abbreviated it. Full event was that there was 2 interviewers, me + other guy. I said to our interviewee, "what's a left join?". Cue puzzled expression and headshake. My co-interviewer qualified that for him: "what's a left outer join?", getting the response "never heard of it". He claimed 4 years of sql on his CV. No job for you, matey.

This isn't rare either, worked at a recruitment office and overheard a conversation which recruitment agent used to check applicant wasn't clueless. Applicant was applying for C++ job. Q: "give me 4 STL containers". Applicant replied "cin and cout".

If you've done no C++ that's like asking a python guy "give me some python data structures" and getting back the reply "input() and print()"

Edit: to clarify about the expression eval stuff, I wasn't expecting code, just an obvious grasp of a tree of objects with relevant subtypes, and eval(). He knew roughly how to do it procedurally, but blatantly had no clue on the OO style (which, yes, he claimed to have on his CV).

Incidentally, I'm just starting my very first step into Pandas today. Looks SQL-ish!