DEV Community: RocketMaker69

Using Object.defineProperties()

RocketMaker69 — Sat, 30 Oct 2021 19:48:18 +0000

Hello, today we will learn how to use Object.defineProperties(/* object */, {
// properties here...
}), which has the following arguments:
object (1st arg): The object to define the properties to.

props: The properties to add add to the object.

Here's an example:

let object = { };

Object.defineProperties(object, {
  a: { value: 4 }
});

console.log(object.a);   // 4

To begin, we pass object as the first argument, so we will add properties to object. Then, we pass an object (the same as a Python Dictionary) as the second argument. You see that every key will be added to the object object. The key bar has another key, value, which is 4. So, it's the same thing as this:

let object = { };

object.a = 4;

But Object.defineProperties() supports adding multiple properties! Remember the interpreter written in JavaScript in the Making an interpreter in Python post? Here's a newer variant:

let i = { };

Object.defineProperties(i, {
  stack: { value: [ ] },
  code : { value: null },
  init : {
    value: function (c) {
      this.i = c.i;
      this.d = c.d;
  }},
  run: {
    value: function () {
      for (let step in this.i) {
        switch (step[0]) {
          case "load": this.stack.push(eval(step[1]));
          case "add":
            let b = this.stack.pop();
            let a = this.stack.pop(); 
            this.run(["load", a+b]);
          case "dump": 
            if (!step[1]) console.log(this.stack.pop());
            else console.log(eval(step[1]));
        }
      }
  }}
});

With this, goodbye and have a good day!

Generators in Python

RocketMaker69 — Sat, 16 Oct 2021 18:18:18 +0000

Hi guys, i'm back! So today we will discuss about generators, which are functions that yield values. The yield keyword is like return, but it doesn't end the function. Here's an example:

def <function_name>(<args>):
    # ...
    yield <something>

replacing the placeholders:

def sq(x):
    for i in range(1, x+1):
        yield i ** 2

To call the iterator methods, do this:

for <something> in <method_name>(<args>):
    <code>

And here is a full example:

def sq(x):
    for i in range(1, x+1):
        yield i ** 2

for i in sq(10):
    print(i)

"""
1
4
9
16
25
36
49
64
81
100
"""

With that, Goodbye guys! Have a nice day!

try-except in Python

RocketMaker69 — Sat, 25 Sep 2021 13:51:44 +0000

Hello! Today we will learn how to use the try-except statements. Here is a scheme of how try-except works:

try:
    # This code tries to execute, but if there's an error, stop execution
except <err_name>:
    # This code will get executed if the try block fails to execute
else:   # Optional
    # This code executes after the try block, only if try block doesn't return an error
finally:   # Optional
    # This code will always get executed

Also, you will need to replace with the error you want to catch. Ok, so let's see an example:

i = input()

try:
    i = int(i)
    print(f"Your number: {i}.")
except TypeError:
    print("Your input isn't a number!")
finally:
    print("Goodbye!")

if we input 6673 we will get:

Your number: 6673.

With that, Goodbye and have a nice day!

Making an interpreter in Python

RocketMaker69 — Sat, 25 Sep 2021 09:27:06 +0000

Hello! today you and i are going to make an interpreter in Python! They're not that hard, also, we're making an interpreter, nod an interpreted language. So, to start off, we will need instructions that our interpreter understands. we will only have 3 instructions for now:

LOAD
ADD
PRINT_RES

so, let's start making the interpreter!

class Interpreter:
    def __init__(self):
        self.stack = []

we define an init() method which creates the stack. We will use the stack to add and remove numbers from it. that's what the LOAD() method will do:

def LOAD(self, num):
    self.stack.append(num)

next is ADD(). ADD() takes the last 2 numbers from the stack and pushes their sum to the stack. Now let's make the ADD() method:

def ADD(self):
    b = self.stack.pop()
    a = self.stack.pop()
    self.stack.append(a + b)

We invert a and b because pop() removes the last item of the stack, not the item at a specific index of the stack:

stack:
[
    6,   <--- This is a (popped after b)
    14   <--- And this is b (popped first)
]

now we have to do the PRINT_RES() method, which prints the last item of the stack:

def PRINT_RES(self):
    r = self.stack.pop()
    print(r)

finally, we will put it all together using a run() method:

def run(self, code):
    instructions = code["Instructions"]
    data         = code["Data"]
    for i in instructions:
        action, arg = i
        if action == "LOAD":
            self.LOAD(arg)
        if action == "ADD":
            self.ADD()
        if action == "PRINT_RES":
            self.PRINT_RES()

We have one if statement for each instruction: one for LOAD, one for ADD and one for PRINT_RES. Here is the finished code:

class Interpreter:
    def __init__(self):
        self.stack = []

    def LOAD(self, num):
        self.stack.append(num)

    def ADD(self):
        b = self.stack.pop()
        a = self.stack.pop()
        self.stack.append(a + b)

    def PRINT_RES(self):
        r = self.stack.pop()
        print(r)

    def run(self, code):
        instructions = code["Instructions"]
        data         = code["Data"]
        for i in instructions:
            action, arg = i
            if action == "LOAD":
                self.LOAD(arg)
            if action == "ADD":
                self.ADD()
            if action == "PRINT_RES":
                self.PRINT_RES()

With that, here is a test run:

code = {
    "Instructions": [
        ["LOAD", 6],
        ["LOAD", 14],
        ["ADD", None],
        ["PRINT_RES", None]
    ],
    "Data": []
}

i = Interpreter()
i.run(code)   # Output: 20

And here, the same interpreter, written in JavaScript:

let interpreter = {
    "stack": [ ],
    "instr": [ ],
    "data" : [ ],

    "init": function (i, d) {
        this.instr = i;
        this.data  = d;
    },
    "load": function (x) { this.stack.push(x); },
    "add": function () {
         let b = this.stack.pop();
         let a = this.stack.pop();
         this.load(a + b);
    },
    "print": function () { console.log(this.stack.pop()); }
};

And a test run:

let i = interpreter;
i.init(["print", "s0"], { "numbers": [], "strings": ["hi"], "names": [] });

And with this, goodbye! Have a nice day of programming!