class factory clear solution for 3 Chefs by Sim0000 - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

class factory solution in Clear category for 3 Chefs by Sim0000

def class_factory(food_name, drink_name):
    class T:
        def __init__(self):
            self.food = self.drink = 0
    
        def add_food(self, food_amount, food_price):
            self.food += food_amount * food_price
    
        def add_drink(self, drink_amount, drink_price):
            self.drink += drink_amount * drink_price
    
        def total(self):
            return f'{food_name}: {self.food}, {drink_name}: {self.drink}, Total: {self.food + self.drink}'
    return T

JapaneseCook = class_factory('Sushi', 'Tea')
RussianCook = class_factory('Dumplings', 'Compote')
ItalianCook = class_factory('Pizza', 'Juice')




if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    def json_dict(d):
        return dict((k, list(v)) for k, v in d.items())

    client_1 = JapaneseCook()
    client_1.add_food(2, 30)
    client_1.add_drink(2, 10)

    client_2 = RussianCook()
    client_2.add_food(1, 40)
    client_2.add_drink(5, 20)

    assert client_1.total() == "Sushi: 60, Tea: 20, Total: 80"
    assert client_2.total() == "Dumplings: 40, Compote: 100, Total: 140"
    print("Coding complete? Let's try tests!")

June 9, 2018

Comments:

colinmcnicholl on July 15, 2018, 6:30 a.m.
Not sure how random these random reviews are. This code is no doubt created by someone with much more coding experience than I have. Nevertheless, I will give it my review. It is readable, being sparse helps in this respect. It is explicit in that it is obvious, given the clear variable names what each of the functions addfood, adddrink and total do. It does not strictly follow the instructions of the mission story, in that it does not create 3 different subclasses, one for each chef which are the children of AbstractChef. Instead it creates one class, for some unknown reason named 'T' and this class is contained within the function classfactory. So lines 16-18 create 3 T classes. Lines 28 and 32 create instances of the T class. Line 29 calls the method addfood on line 6, etc. So it achieves the desired result without the creation of subclasses. I find it hard to understand the role of lines 25 and 26 the json_dict(). Line 13 is on the long side at 108 characters.

Sim0000 on July 15, 2018, 7:41 a.m.
Thanks for your review. For your reference. Design patterns were created for old specification languages like C ++ and Java. This code uses Python's closure (foodname, drinkname). I also use a function that returns classes. These features are not in C ++ or Java.

J.W on Aug. 23, 2018, 3:01 p.m.
Advanced. :)

mindaugas.dadurkevicius on Sept. 3, 2018, 12:01 p.m.
Very thoughtful design

coryphoenixxx_981f4bd73e7a40ac on July 13, 2020, 3:50 a.m.
Nice

jvollme on Aug. 30, 2020, 8:57 p.m.
i don't quite get it. the food and drink names are passed to the factory function, but apparently not integrated into the classes or class-instances themselves? How does this work? How can these parameters be persistent after object/instance creation is done?

Sim0000 on Aug. 31, 2020, 1:40 a.m.
The foodname and drinkname are used in line 13. Do you know about Python's closure? For example, the function adder, which creates a function that adds n to a given x, can be created as follows: <pre class='brush: python'>def adder(n): def f(x): return x + n return f # return function f itself add5 = adder(5) add2 = adder(2) print(add2(3), add5(7)) </pre> Parameters passed to adder are persisted in add2 and add5. The function class_factory creates a different class T for each parameter and returns T itself in line 14. This uses the closure mechanism. I hope this may help you :-)

jvollme on Sept. 12, 2020, 1:11 p.m.
hmm, not sure i quite understand yet: I get that variables defined in a function are persistent in the subfunctions of that function as long as that function is "active". BUT, in this case the function "dies" as soon as the instance is returned. So how can these variable still be persistent aftwards (AFTER the instances were created and returned, and the factory function has "died"), if they were not explicitly integrated into the class/instance? Guess i do have a lot to think/learn about how "closure mechanisms" work in python...

Sim0000 on Sept. 13, 2020, 10:13 a.m.
As I understand it, every function in Python has an attribute called __closure__ that holds a value in it. See <a href="https://docs.python.org/3/reference/datamodel.html">callable types section</a>. In fact, in the adder example above, a tuple is stored in add5.__closure__, as shown below: <pre class='brush: python'>print(add5.__closure__) (<cell at 0x000002091C0F5288: int object at 0x00007FF8C2F493C0>,) </pre> That's almost all I know. I hope this may help you :-)

flowerinapot on July 27, 2023, 7:12 p.m.
What's doing here? <pre class='brush: python'> def json_dict(d): return dict((k, list(v)) for k, v in d.items()) </pre>

Everything is Object

0 %

PyCharm The Python IDE for Professional Developers. Enjoy productive Python, web and scientific development with PyCharm. Download it now!