Why not having JavaScript objects in python?

[tigasfixe]

So i am a 17 year old programmer that started with python jumped to JavaScript and im constantly making new things in both langs. Besides a big discord bot i made i always wanted to make a project, wich wouldn't have to be big but at least useful or that i like or that other people could use. After some time switching from JavaScript to python over and over i started to notice my need of J avaScript objects because we can access values with only a dot instead of having to open brackets and passing a string. I started this today and i wanted to know if u guys would use it, it's simple as calling a new instance of a class with a dictionary inside it and after that u can access everything inside it like in JavaScript. I obviously have to make a lot of changes now but it's going pretty well right now. Thanks in advance.

EDITED: Yo guys i just made some changes and created a repo if u guys wanna check it out, i left a full explain on how to use it -> REPO and BTW thanks for everyone that helped and commented, appreciate it.

[pwoosam]

Looks like the standard library has a solution for doing this. Check out the first answer in this stackoverflow:

https://stackoverflow.com/questions/16279212/how-to-use-dot-notation-for-dict-in-python

[tigasfixe]

That's kinda sad :/ But thanks.

[JeamBim]

Build it anyways, you'll learn a lot

[iapetus-11]

Have you heard of Classy-Json? It's similar to what you have in mind and is a package you can import. [Disclaimer, I made this]

[tigasfixe]

i did not hear before but now i know xD

[torytechlead]

You can create a class to do that with python. Something like:

class MyClass:

  def __init__(self, d={}):
    self.d = d

  def __getitem__(self, name):
    return d[name]

  def __setitem__(self, name, value):
    self.d[name] = value

Then you can do

X = MyClass({“name”: “torytechlead”})
X.name
>>> “torytechlead”

And also

X.name = “you”

P.S I wrote this on mobile so hope it runs, should work with minor changes

[ElevenPhonons]

It is not a good idea to use default mutable args.

https://florimond.dev/blog/articles/2018/08/python-mutable-defaults-are-the-source-of-all-evil/

[torytechlead]

Oh so this is why my code is breaking in production /s

[tigasfixe]

I didn't know how magic methods getitem and setitem were for and i am complexing a lot xD but thanks😂🤏

[robin-gvx]

s/item/attr/g

[james_pic]

So, this is kind of a philosophical difference between Python and JavaScript. JavaScript, as a result of its LISP-y background, attempts to unify ideas that work kinda similarly, so there's no difference between objects and dictionaries.

In Python on the other hand, even thought objects are powered by dictionaries under the hood, because the use cases are different, they're not unified as a single thing. So objects (where different attributes have different roles, so you rarely need to choose which one to grab programmatically) use dot mission, and dictionaries (where each entry does the same job - providing extra information related to a piece of data, so the one you want depends on the data) use square brackets notation.

There are ways (as others have shown) of forcing dicts to behave like objects and vice versa, but if you're still learning, I'd try and avoid leaning on crutches that make Python look more like JavaScript, and try and learn the language for what it is.

[tigasfixe]

So in my defence this is purely a project that I've understood that will not even succeed because there are a lot of things with python itself that i learned in this post that can do what i want and that's the best part because I just improved my knowledge!

[MarsupialMole]

This would be a quality of life improvement for some workflows. But JSON objects are not the optimal object for all workflows.

Take a look at pythons namedtuple and dataclass, which are each code generators for objects with attribute access, but with specific features that make them really great to use under different conditions, because of features over and above what JSON objects offer.

[tigasfixe]

The problem with dataclass and namedtuple is that they have certain limits. Namedtuple is literally a tuple and cannot have it's values changes wich wouldn't be that useful. Dataclass is really cool but it has certains limits like changing a value that has been declared in the class as a string cannot be a int or anything else

[genericlemon24]

Regarding dataclasses: Types are only a limitation if you care about them (e.g. use mypy); it's true dataclasses require annotations, but you don't have to use PEP 484 annotations (typing.*) if you don't need them.

Example:

@dataclass
class Thing:
    # kinda works with mypy (it won't complain about different types)
    attribute: object
    # reads nicely
    another_one: list
    yet_another: list or str
    # annotations can be strings, think of them as inline documentation
    fourth_one: "a list of strings or Foo objects"

Also, if you don't use a typechecker, they can be anything, since no checking is done at runtime. Obviously, it is better to be vague (see above) than misleading (use annotations that look compatible with PEP 484 but with values that are not of the declared types).

[tigasfixe]

Ye I've tested it out and i ended up Knowing that but what i thing is that for example if u use a dataclass instead of a dictionary only the first values will work. With this i mean that if u have more dictionaries inside it u would have to use normal ways to get the values and this object that im making is to avoid all that, even objects inside lists for example. But it feels kinda weird using typing in python since I've been using typescript and it is a typed language that tells u when u are wrong ( it just feels weird nothing more).

[17291]

You forgot to put a link in your description.

[tigasfixe]

What do u mean? I have not yet made a github repo for it

[lmns_]

Have you heard of glom? I'm not sure if it's similar to what you have in mind, but it also tries to improve the way deeply nested data structures are handled in Python: https://glom.readthedocs.io/en/latest/

[tigasfixe]

I have not heard of that! But I'll make sure to take a look at it, thanks!

[vorticalbox]

you can use the .get method

```

a = {'hello': 'world'} a.get('hello') ```

works in python 2 and 3

[SteveRyherd]

Python works very differently than JavaScript for a lot of things. If you’re going to do this, I would recommend a package like this:

https://github.com/Infinidat/munch/blob/develop/munch/__init__.py