First off, you can’t not use an object in Python... the dict type you’re pushing as the solution is an object, one that receives all of its utility from inheritance. So are ints, bools, floats, tuples, arrays, deques, and for that matter functions... there’s literally not a single primitive type in Python that isn’t a subclass of object and doesn’t rely on inheritance. So your basic premise falls on first blush... if you’re using the language at all then you’re using objects. What you’re actually saying is don’t use classes in Python, not objects. But that’s silly advice; classes exist to encapsulate related behaviors with state, and there’s plenty of situations in which there are no public attributes (ie state) of consequence, but excellent arguments for keeping the behaviors together... database connections, socket wrappers, GUI widgets, none of which can reliably or sensibly be modeled with a dict. Ahh ... you don’t really mean don’t use classes any more than you mean don’t use objects, you mean don’t use dataclasses / records ... ie classes that contain primarily data / state, and have no (or very few) methods. Well, I’d still argue with that... the namedtuple can be far more efficient than a dict for records (and isn’t a wrapper around a dict), and while the new dataclasses.dataclass isn’t quite as lightweight as a dict it’s a lot more expressive and easier to reason about, once you start using mypy. So, overall, I’d say you’re giving kind of problematic advice and leaping past a few things along the way (for instance it’s entirely possible to make functions that discriminate on type, though you can’t get much more polymorphic than duck typing) while stating it all in an unsupportable and kind of click-baity way. Not that there aren’t lots of of good arguments for avoiding leaning on inheritance in Python — typically I find that’s best reserved for numerical types, specialized variants on existing primitives (for instance collections.Counter), and in architecting plug-in systems using abc.ABC — but you’re kind of tossing out baby with bath water in these posts. More on reddit.com

classes are like self-contained pieces of code. Attributes are just variables that belong to the class. Methods are functions that belong to the class. Objects are made out of classes. all the usual stuff is in there, def for a function and so on. you declare them like this and then write the code for them beneath the class declaration. The starting place is init, and you pass things to it just like a normal function. all functions and variables which are used throughout the class must be preceeded by self. but any you are using in say a for loop can just be simple i or x. the first thing in a function def must also be self class A(object): def __init__(self, x, y): self.x = x self.y = y total = self.add(x, y) print(str(total)) def add(self, x, y): total = x + y return total def counter(self): for i in range(10): print("i = " + str(i)) then you make objects like this: my_obj = A(1, 2) and call object methods like this: my_obj.counter() msg me if you have any questions. More on reddit.com

Objects in are the equivalent to "Things" in programming. In general, a Thing has a name, it has attributes/properties, and you can do stuff with it. The object equivalent of those are the class name, class properties/attributes, and methods (which are basically just functions inside objects, unless you want to be really precise). Objects are a pretty intuitive way of grouping Things together that are similar, by defining a template of the generalized concept of the Thing and its associated attributes/methods. Now, you can take this concept of defining something like this to the logical conclusion that everything you can imagine, anything you can name, fits this schema. This is pretty much what python did. Under the hood, most aspects of the language itself work like objects. They belong to a class, which has a name, and they have certain operations pre-defined that you can do with/to them. Notable examples that I can think of are None and small integers as well as Type, but I might even be wrong on those, so don't quote me on it. Object-oriented programming is a way of thinking, a method to model reality and make the code easier to structure/read/reason about. Read the wikipedia article comparing it to procedural/functional programming and you will see it is just the logical next step in abstraction after those. More on reddit.com

Al sweigart, python author, explains it better than I can https://inventwithpython.com/blog/2014/12/02/why-is-object-oriented-programming-useful-with-a-role-playing-game-example/ More on reddit.com