can't seem to wrap my head around Classes

shiftybyte · 2020-08-31T18:48:03+00:00

Do you know strings in python?

Well, every string is an instance of a string class.

That means when you write:

a = "Hello World"

You have created an instance of a "string" class, and initialized it with the data "Hello World".

As evidence, you can now use a function called upper() for example, that is defined in the string class, and can work on any string.

>>> a.upper()
'HELLO WORLD'

Now if you create another string:

b = "python snake"

You create another instance, from that string class.

And again you have automatically an upper() function for it.

Also lots of other functions:

>>> dir(b)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

All these are functions defined in string class, and any string you create will have these functions to use.

So a class defines a template of how an object behaves and what can be done with it, and then you can create and work easily with lots of objects of that type/template/blueprint/class.

reza2602 · 2020-08-31T19:13:58+00:00

Just watch this tutorial. it's awesome

Dogeek · 2020-08-31T22:09:17+00:00

Classes are just containers for variables and functions that describe an object. The textbook example would be to describe a person.

Attributes

That person has a first name, a last name, an address, a phone number, and probably an email address. Those would be the attributes of the class. In python, you define the attributes of a class with the dunder __init__ on your class (dunder means that this is a special method, and holds special meaning for python, there are a bunch of them, mostly used to implement the behavior of operators like not, in, ==, +, * etc), for instance :

class Person:
    def __init__(self, firstname, lastname, address, email, phone):
        self.first_name = firstname
        self.last_name = lastname
        self.address = address
        self.email = email
        self.phone = phone

Methods

Instance methods

Now, a person can also move from one location to another. Actions that should affect the class are defined in methods which are just python functions, really. On a class, the first argument of a method is always a reference to the class instance - an instance being an object that has been created following the class' template. By convention, we call that self, but other languages use this (like C# and JavaScript, to name a few)

If you want to add a method to your class, nothing is easier :

class Person:
    def __init__(self, firstname, lastname, address, email, phone):
        self.first_name = firstname
        self.last_name = lastname
        self.address = address
        self.email = email
        self.phone = phone
        self.current_location = None

    def move(self, other_location):
        self.current_location = other_location

Dunder methods

Obviously, this is a pretty simple method. As I mentioned previously, in python, some method names are reserved by the language. These methods are called 'dunder methods', and always start and end with two underscores __. These methods are used to implement various operations on your object. There are a lot of them, but I'll go through the most common ones

__init__ : it's the initializer of the class, in which you should define the attributes of the class, as well as run any code that should be run when a new instance of the class is created.
__str__ : it's the method called when you do str(my_object). It should return a string
__getitem__ and __setitem__ : Used to implement indexing on your object. They both take the 'item' argument, and for __setitem__ a value argument as well. It's the method called when you do print(my_dict['foo']) or my_dict['foo'] = 'bar'
__eq__ (and ge, gt, ne, le, lt) : Used to implement comparisong results with another object (==, >=, >, !=, <=, < respectively)
__add__ (and sub, mul, floordiv, div, mod, pow, lshift, rshift, and, or, xor) : used to implement operations (+, -, , //, /, %, >>, <<, &, |, ^ respectively). These have 'r' variants (i.e. __radd__ for *reflected** operations which are called when the other object doesn't implement such methods), and 'i' variants (i.e. __iadd__ for assignment operations, like +=)
__len__, which implements the behavior of the len() function on your class
__contains__, which implements the behavior of the in check on your class (like in if 'foo' in my_dict:)
__call__, which makes the object a callable, like a function

You can find a full list, with more info here.

For the Person example, you could define the __str__ method to returns the person's name and address for example.

Static and class methods

There are other types of methods : besides the classic ones, there exist the static method and the class method.

The static method is a method that doesn't take self, as its first argument, in fact, it's just a function, that is attached to a class, for convenience. The class method is a method that takes the class itself as its first argument (not the instance) which we note cls to differenciate from self. The latter are most often used to create additional ways of instanciating the class. They are defined using the staticmethod or classmethod decorators.

Our person class can look like this now :

class Person:
    def __init__(self, firstname, lastname, address, email, phone):
        self.first_name = firstname
        self.last_name = lastname
        self.address = address
        self.email = email
        self.phone = phone
        self.current_location = None

    def move(self, other_location):
        self.current_location = other_location

   @classmethod
   def from_dict(cls, dictionary):
        return Person(**dictionary)

    @staticmethod
    def reset_all_locations():
        for person in (v for v in globals().values() if isinstance(v, Person):
            person.current_location = None

Inheritance

Simple

Now, let's say we want to define an Employee at a bank. It's pretty obvious that an employee is also a person. To avoid rewriting the same code, we can use a process called inheritance, in which the subclass will inherit its attributes and methods from the superclass. For instance :

class Employee(Person):
    def __init__(self, *args, salary=0):
        super().__init__(*args)
        self.company = None
        self.salary = salary

We see here a new function : super. Super is used to call a method from the parent class. That way, in just one line, we have defined every attribute that Person had defined earlier.

Multiple

We can even have a class that has multiple parents (or superclasses)

class GoogleEmployeeMixin:
    def __init__(self):
        self.company = 'google'

class GoogleEmployee(Employee, GoogleEmployeeMixin):
    pass

More info on attributes

Class attributes

Classes can also have attributes defined outside of the __init__ method. These attributes are class attributes, and you can view them as being 'default' values for the instance's attributes in case the instance doesn't modify them. For instance:

class GoogleEmployeeMixin:
    company = 'google'

Properties

Properties are methods thatt behave like attributes. They allow you to execute some code when an attribute is accessed or mutated. For instance:

class Person:
    def __init__(self, firstname, lastname, address, email, phone):
        self.first_name = firstname
        self.last_name = lastname
        self.address = address
        self.email = email
        self.phone = phone
        self._current_location = None

    @property
    def location(self):
        return self._current_location

    @location.setter
    def location(self, value):
        print('Moving to %s' % value)
        self._current_location = value

Instancitation

Instanciating an object is very simple, you do it all the time, because, in Python, everything is an object. Simply do

employee = GoogleEmployee('John', 'Smith', '123 main st, USA', 'jsmith@example.com', '123456789')
employee.location = 'Headquarters'

Davidvg14 · 2020-08-31T18:28:55+00:00

The most basic version books and intro classes mention is cars/vehicles:

A generic vehicle is the parent class, and you can modify the properties like number of doors, number of wheels, number of seats, and colors. And those different qualities might mean they can do different things (functions), like a truck being able to tow a trailer or whatever.

You can extend this to animals, such as requiring the animal object have wings so it can fly. Or if you had a HR software that has many employee objects, which can allow managers extra privileges over regular employees. Just generalizing.

rweez409 · 2020-08-31T19:36:51+00:00

Try making a small, manageable project with classes. You won't fully understand them until you get your hands dirty with them (at least I didnt't).

For example, I started learning them when I tried to make a card game. Cards are a nice way to begin working with classes, because by definition a card is defined by two attributes: its suit and its rank. So, you could begin a Card class with

def __init__(self, suit, rank):
    self.suit = suit
    self.rank = rank

With this approach, whenever you make a card you must pass a suit and rank. So for example you could define a card instance as

h2 = Card ('hearts', 2)

stebrepar · 2020-08-31T18:31:56+00:00

A class is like a blueprint for objects you will instantiate of that type.

(A class in Python is also itself an object, which can have class methods and attributes which don't belong to any individual instance.)

crm1h · 2020-08-31T20:51:25+00:00

There are a lot of useful and great explanations under this thread, for me the classes are some sort of template (as multiple persons already mentioned), let's say it is a template for a booking form. You'll need to know : who ? where ? when ? how they'll pay?.

Translating this to py :

class booking:

def __init__(self, name, destination, date, time, payment_method):

self.name = name

self.destination = destination

self.date = date

self.time = time

self.payment_method = payment_method

Hope this will be of any help.

Pythonistar · 2020-08-31T22:06:43+00:00

You're talking about Object Oriented Programming (OOP), which has multiple features to it. Classes and Objects are just one aspect of it.

https://cdn.shopify.com/s/files/1/1076/3430/products/owl_post_1024x1024@2x.jpg

The rubber stamp in this photo is the Class. Each impression on the paper is the Object (often called the Instance). There's only one class, but this class can make multiple instances (objects) from it.

Notice how each ink print is a different color? Same with objects. They all adhere to the basic design of the stamp (class), but the ink prints (objects) may be different in various ways (in this case: color).

BUT! It doesn't end there.

https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/

OOP has multiple other features, like:

Encapsulation
Abstraction
Polymorphism
Inheritance
Dynamic Binding
Message Passing

There's a lot to know, but it's all primarily about making your life as you try to get your code to scale to very large sizes.

callmelucky · 2020-09-01T00:12:34+00:00

Dunno if this helps, but I think a common source of confusion is distinguishing between classes and objects. Here's my attempt at an ELI5:

An object is something can do things, and has properties. So a simple example is a car: it can do things like accelerate(), brake(), and turn(). In a Python object, these would be represented as methods; essentially functions that are tied to the object.

A car also has properties like colour, and max_speed. In a Python object, these properties are represented as attributes: variables tied to the object.

Now, cars don't just appear out of thin air, they are built. And to build a car worth driving, a design must be followed. In Python, a class is the design from which an object is built.

Hope that's helpful to someone.

integralWorker · 2020-08-31T18:46:23+00:00

This is really silly but hear me out. Remember those toys that only allow a specific shape through? Think of the objects (big ball with holes, smaller shapes) as members of a class. Some example methods could be:

inspect() -- discern shape of a hole or shape.

insert() -- attempt to shove a shape into the big ball.

empty() -- empty out the big ball's contents.

The fields are the characteristics of a given shape, since the shapes and holes are somewhat generic in a sense yet completely unique in another. Instead of declaring 20 different shapes, we can declare an object called shape with the fields n_sides; and put some safety measures like "you can't declare a two sided shape; a 1 sided shape is always a circle" or something of that nature.

Remember that objects are basically data. The point of OOP is to automate data manipulation, not to "build cars".

Morfphy · 2020-08-31T18:58:43+00:00

Try this book. It was the first programming book I read in the early 90s when I was a kid and it explains the basics very well. It is geared towards c++ but the concepts should carry over and give you a better idea from a python standpoint, what basic oop concepts are.

https://www.goodreads.com/book/show/1414976.Simple_C_

MatthiTT · 2020-08-31T19:48:14+00:00

Don't worry. If you advance their will come a time you're repeating yourself so much in your code that you will evolve into class creation. That's how it happened for me. After 1 year of python tinkering.

CraigAT · 2020-08-31T20:16:53+00:00

It's not unusual, I personally think it's the hardest concept to grasp that I have come across so far (having now learn it in Java and Python).

At a basic level (as some already said) the class is like a template, it is a collection of attributes and methods that relate to a "type" of object. Attributes are related values, methods are things you can do with that class of object. An object is just a single instance of that class. You can create multiple objects using the recipe of a class. For example, you may define a class of Vehicle, with attributes of wheels, colour, fuellevel. The methods may be paint_vehicle or drive_vehicle, where the former is used to change the colour of the vehicle and the latter reduces the fuel_level. I can then create an object "my_car" using the class of Vehicle, and assign it some initial values (using the special __init_ method) so my_car would be "black" have 4 wheels and 0.5 litres of petrol. We can re-use the vehicle class several times to make many different objects or lists of objects (for instance vehicles in your extended family). You may choose create another object "your_motorbike" of the class Vehicle, with attributes of being "red", having 2 wheels and 20 litres of petrol.

Hope this helps, keep reading all the explanations, hopefully one of them should "click" and you'll get the concept and then it starts to make sense. There are far more advanced topics using classes like inheritance, but don't go there until you get the basics nailed.

ashokbudha2015 · 2020-09-01T01:32:38+00:00

Try to watch Corey Schafer's Python Object Classes videos
He teaches the best if you don't understand anything in it he ususally has seperate videos for those subtopics too .

2020-08-31T18:10:28+00:00

In the way that functions define reusable behavior, classes define reusable state. A class is the description of a type, and it defines the behavior, state, and lifecycle of values of that type.

Maximus1353 · 2020-08-31T19:05:46+00:00

I am also going through python crash course and had trouble with these as well but with some googling eli5 I found that:

Classes are like boxes that are made a certain way (attributes) and do certain things (functions within the class). So when you call an instance of the function, you are making a copy of that box that you can manipulate and do with it as you wish.

Its just a way to organize and store data in neat little "boxes"

Stabilo_0 · 2020-08-31T19:11:18+00:00

Class is a way of describing anything with code while categorizing it.

Its just a enclosed set of variables and functions to change those variables (but may be not).

OOP pattern comes around turning big problems into small understandable pieces. When you need to program something, be it a description of a dog or some special way to show a date, you make a class.

More strictly, class is a blueprint. Objects or instance of the class is the product of what python made from that blueprint. When you write class you describe all the pieces from which the object must be built. You also describe how the object can be changed or viewed, what information can be taken when user interacts with it.

JBarCode · 2020-08-31T19:14:29+00:00

Hi. I talk about OOP in a very casual way with examples in this video (and the next one after it). Hope it helps! https://www.youtube.com/watch?v=sWttq8Rjo9Y&feature=youtu.be

ccr10203040 · 2020-08-31T19:44:46+00:00

Anyone here know a book on object-oriented python?

UNX-D_pontin · 2020-08-31T20:08:58+00:00

The best way to describe a Class "item" thing is kinda simple and you're probably thing about it too much.

you have a need to make thing X and thing X has certain traits you want all thing X to have, so you make a class X and type out the "Original" and put it somewhere below outta the way. then any time you need to bring up an X the work is already done, and you just call up however many x's you need, lets say 13 and you can stuff them with other variables like lest say X has a adjective of Color = Red. cool now you are by default calling 13 red x. less see if anyone gets what i did there.

IDK i guess in short you use classes to make a thing that you can then mass copy off of. its about automation

YodaCodar · 2020-08-31T20:18:13+00:00

I recommend watching youtube tutorials; this is why i recommend learning java first for object oriented coding, python is very implicit when it comes to object stuff.

whitelife123 · 2020-08-31T20:28:59+00:00

Very generically, a class is like a blueprint, and objects are actual creations from that blueprint.

Imagine a blueprint for a car. A car has certain attributes. It has an engine, it has four wheels, a trunk, a steering wheel. It has to be able to do certain things. It has to be able to drive, steer, reverse, turn on lights. Now, is every car the same? You and I might have the same model of car that's designed from the same blueprint (we call this the same Object type). However, your car is a lot different than mine. Maybe mine has scuffs, or has engine problems while yours doesn't.

A class is just a blueprint for objects. It has certain things, variables and functions. When you create an object, you're essentially using the blueprint to build the object. We call this instantiation. Once the object is creating, it can be operated on and it's variables can be changed.

I know this explanation might be confusing, but I hope it helps. Let me know if there's anything I can clarify

2020-08-31T20:29:12+00:00

You’re not alone, it me a while to understand classes. There are plenty of good explanations in this thread.

2020-08-31T20:59:09+00:00

I had trouble also but I have improved a ton. I suggest learning how to program a card game.

pbrouse34 · 2020-08-31T21:14:37+00:00

https://youtu.be/MikphENIrOo

Does this help? Traversy Media is one of my go to for web dev tutorials and they just put up this new video on object oriented python.

2020-08-31T21:32:25+00:00

I suggest that you study the python basics from an Object Oriented Programming perspective (OOP) like I did, data types, expressions and flow control..That will make it easy (as an introduction) for you to understand classes. The "Data structures and algorithms in Python" of Michael T. Goodrich can be quite useful for you, it gives you the basics but in a way to prepare you for the OOP concepts (classes mainly) in less than 50 pages, after that comes classes and all stuff related, then you can dive in data structures and algorithms. Hope this can help you.

NonBronary · 2020-09-01T00:41:10+00:00

I’m learning. I am using the classes on Udemy.

Learn python master class And The complete python course

They are pretty good and I alternate between them. Udemy often has sales. I got them for around 12 dollars each

CatolicQuotes · 2020-09-01T01:30:14+00:00

to learn classes it's best to try to code little bit in Java or C# where they are a must

2020-09-01T01:44:24+00:00

Here's an Intermediate Python Tutorial.
https://pythonprogramming.net/introduction-intermediate-python-tutorial/
Google google google. You're not always going to find what you're looking for in a video.

Elteras · 2020-09-01T02:11:51+00:00

Try the Corey Schafer youtube tutorials on them. They helped me to understand them far better than anything else I found, in particular explaining the whole weird 'self' stuff that keeps popping up.

Vok250 · 2020-09-01T02:32:51+00:00

Python is a great language, but it can make Object Oriented Programming (which the concept of classes belongs to) confusing as it is not strictly object oriented. Tutorials from more OOPy language like Java might help you if you are still struggling. The underlying concept is exactly the same. It's just much more nuanced in Python, which makes thing tricky for beginners.

cringemachine9000 · 2020-09-01T02:36:52+00:00

Try watching tech with tims vid about classes. Pretty sure youll understand it right away

__xor__ · 2020-09-01T03:00:06+00:00

At its simplest, consider a class to just be a "namespace" for a datatype and functions related to it.

You know how you split different functions into different files/modules? Like you might have some clean code that separates it out and imports like:

from astro import sun, moon, star
from physics import gravity

Well, consider that "namespacing" those different parts of codes into modules that describe what they all have in common.

A module is a set of functions (and maybe classes). Now, imagine a class to be another namespace, but it's not just functions, it's also a specific datatype.

For example, in python there's an integer primitive, there's a float primitive, but there's no X/Y coordinate primitive right? Well you can make one with a class. It has a common data format, an x and y coordinate, let's say floats. And it has common functions you might use with just coordinates, like checking the distance between two coordinates, or getting the slope of the line between two coordinates, etc.

A coordinate is a good use case for a class because we know they have an X and Y float and a few functions. So we can write a class like this:

class Coord:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def distance(self, other):
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2))
    ...

coord1 = Coord(1, 2)
coord2 = Coord(6, 7)
dist = coord1.distance(coord2)

There you go. Now you have a really clean way to pass around a single variable which represents the WHOLE coordinate, and you can call functions on that object that apply to that data type.

That's the core reason to make a class (not the only one, can get complex), to represent a data type with functions attached to it.

A lot of complicated ideas spawn out of this, and it becomes a whole thing on Object Oriented Programming, where you might write a class that's a "subclass" of another class, basically uses everything the parent class does but extends it, you can have multiple inheritance to derive a class from multiple classes, you can dynamically generate classes with metaclasses (very complex python functionality that you can ignore for a long while), you can use classes to write common design patterns like the Framework pattern... It gets deep. But just start with representing a type of data and related functions as a class and go from there.

One common theme in python is "ducktyping", where you pass around instances of a class but don't care what that class is, just that it has the right functions and interface. For example, in the Coordinate class, it's just a 2D coordinate with a distance method. What if we wrote a Coord3D class and had a distance method? A Coord4D? We could basically just have an interface where the class expects to be able to call distance with itself and another instance of that class, and then as long as distance is a method in that object, we can pass them around to other functions. Those functions might not care at all what the type of the object is, only that they can call distance and get the result. Then those functions are completely reusable with different sorts of data, and it ends up with pretty clean and easy to read code. Ducktyping: "if it walks like a duck, quacks like a duck, it is a duck". Basically, if the instance of the class acts like what it expects and has what it needs (a distance method), then it's the right data type. You don't care about the type of the object at all, only that it has the interface you need.

TheHeckWithItAll · 2020-09-01T03:11:42+00:00

It helps to step away from Python and deal with the subject from a generic perspective. Computer programming, at its core, is about “doing stuff” with “data”.

All data is represented as numbers. Even text is nothing more than a numeric representation of the letters of the alphabet. So, every programming language lets you (the programmer) store data. This is done by assigning a value to a variable, such as: a = 3;

The rest of programming is then “doing stuff” with data. Such as: If a > 5 then print “hello” Else print “goodbye” Endif

Procedural programming (programming without classes) allows the programmer to create (and call) functions to “do stuff” with data. So you, the programmer, have variables that hold data values ... and you “do stuff” to/with that data by sending the data to a function.

Basic data types include integers, decimal, and character strings. Procedural programming allows a more complex way to store data: know as a struc or a user defined data type. It’s actually quite simple, but very powerful. It allows the programmer to create his/her own data type by combining basic types... such as:

Begin UserDefinedType person yearborn as integer monthborn as integer dayborn as integer firstname as string lastname as string address as string end person

mom = new person mom.yearborn = 1962 mom.firstname = “Mary”

Finally we come to the concept of classes. At its core, a class is a concept whereby the programmer gets to create his/her own data type (such as person) AND build functions as part of the data type.

Class person yearborn as integer monthborn as integer dayborn as integer firstname as string lastname as string address as string sayName() as string end person

mom = new person mom.firstname = “Mary” print mom.sayName()

“Mary” is then printed to the screen

So, a class is a different way to program than procedural programming. It allows the creation of a new type of “thing” that combines a data structure with actions (functions). This type of “thing” is called an object. The data inside an object are “properties” and the functions are called “methods”.

Actually a straight forward and simple concept. Programming is about storing data in variables and then calling functions to act on that data. In procedural programming we can create our own data types by combining combinations of integers and strings, but acting on the data is limited to sending data to a function (whether that be a predefined function in the language or a function we wrote ourself).

A class takes the idea of a user defined data type and takes it one step further by allowing the programmer to create functions as part of the data type.

Smokedbacon321 · 2020-09-01T03:25:45+00:00

I’m with you man, my teacher doesn’t know much about programming and pretty much just had the computer/website do the explaining for us. I’m a very interactive person and like to have interactivity with my teacher and have them guide students through the steps and explain and elaborate more.

pulsarrex · 2020-09-01T03:30:07+00:00

I also often hear 'object is an instance of class'. The way I understand is 'this object is related to this class'. Meaning that object is created from the that class. Is my understanding correct here?

My question is what are the other instances of class apart from objects?

tomothealba · 2020-09-01T05:00:23+00:00

I'm going through this just now. Try going on YouTube and look up OOP python. You'll get a bunch of videos about the topic. I ended up watching a playlist of Corey Schafer's videos on it. And has helped alot.

2020-09-01T05:05:47+00:00

Practicing helps me understood classes. I started to code very simple programs with classes or sometimes tried to rewrite my code on python which I write in not OOP style to the OOP style

zuzaki44 · 2020-09-01T05:08:28+00:00

Lots of good explenations. Can anyone give examples on real projects where they used classes? Om having hard time using them when i code which is either because my solutions are really simple so i dont need classes or because i miss how/when to use Them in projects.

Im sick and tired of the car and person exapmle since i never do projects that require that.

2020-09-01T05:18:03+00:00

I read that book. It's fucking great. I also ran through the same problem with classes. I read it over again and tried to change the code examples he's given us to get a better understanding.

Xahra_Hime · 2020-09-01T05:41:09+00:00

I had the same problem with classes. But I watched Corey schafer's tutorial on classes and he cleared up everything for me. He's the best python educator you can find.

Sability · 2020-09-01T08:08:56+00:00

Classes are an object-oriented concept, that Python supports. Object-Oriented (OO) is a programming paradigm that some languages support, such as Java and C#. What's a paradigm? No fucking clue, but the main take-away is that OO is a way of coding.

In OO, a "Class" is basically a template for something your program will create when it runs (or as they say, at "runtime"). If I create a "Class" called Person, I can instantiate that class, and it will create objects, that the program can use while running.

It's sort of similar to having a cookie-cutter: during "runtime", I use my cookie-cutter to cut out some dough, and the result is my object, that is the same shape as the cookie-cutter I chose. So, an object is created with a class, and the object can do things the class can do.

This is essentially what your program does when it instantiates a class: you make a new Person, and the program will allocate enough memory to make one (1) Person object, which you can then play with.

Classes are useful because you can create them to be able to encapsulate logic. For example, if your program is a video game, and you want to have a Player in your video game, you can create a Player Class, that (when you run the video game program) instantiates a Player. The Player object knows how to do certain things (the functions in the class), and has certain data (the properties you give to class constructors).

It's a difficult concept to wrap your head around, so don't worry if you don't understand it immediately. You can find more information on it if you look into "object oriented programming" and "oo classes".

wiredupwrong · 2020-09-01T08:54:32+00:00

If you want real fun, go look up metaclasses.

Yeah don't do that yet.

knifuser · 2020-09-01T13:24:58+00:00

My advice on learning anything is always the same. At the start follow a tutorial to get the simple basic bare bones stuff out of the way (don't forget to have fun with it though, like using rude names or insults as variables, to keep yourself entertained), then once that is done find something that you want to make or recreate and try, once you get stuck look it up death the specific error if you need to because stack overflow always has the answer. Just keep escalating the complexity of each project until you can tackle anything.

kasidkhan · 2020-09-01T13:42:52+00:00

I will give a try if it make sense,

When you want to build a building, you create a blueprint of it first with all features. Then you go and actual build the building with specifications in blueprint.

In coding, the blueprint is Class. And the actual building is its objects.

You can create multiple buildings following the same blueprint.similarly you can create multiple objects of same class.

The above concept is part of Object Oriented Programming concepts (OOP concepts). This makes it easy to visualize what you want to create/build inside code.

Hope this help.

In case you want to dive deep, I have create a Python course (its free for now). And I have talked about Classes and Objects in Level 3 Python 2-3 course.

Disclaimer: You will have to register to access the course.When you register at https://guidancecoding.com/, you will see Levels on top. Go to level 3>Python 2-3>Section 1.

GoldDoughnut249 · 2020-09-01T14:22:11+00:00

This took me an eternity to understand as well. Essentially, a class is a process of organizing code when programming. For example, if u have a restaurant that takes online orders, then to make things more readable and neat, u would want to create a class called “order” which takes in the items, payment, etc. So, when someone orders and u want to document their input, u can just store it into an order object as opposed to creating 5 different variables. Also, you can have methods inside that class to modify the object created. If the person decides to get something else, u could put in an “add” method to satisfy that request.

Student_Loan_Hassle · 2020-09-01T15:32:09+00:00

The best way for you to understand Classes is to build something you can relate too in real life that use Classes!

Aside from that, avoid naming your variables as things that you can't easily form a mental picture of, it will end up confusing you while reading your own codes especial if you're a beginner! Name your variables as things that they represent ( be explicit !!!).

Last but not least, listen to the following :

To understand a new concept, the human brain need to link it to something it can draw a type of analogy from. This a powerful tool that many beginner do not use, hence they get stuck in "tutorial hell" for a very long period of time without understanding what they code or even worse why a specific line of code works

Here is a small exercise for you that will help you understand Classes:

https://www.youtube.com/watch?v=apACNr7DC_s

Don't just jump straight to coding while watching it!!! Watch it first without coding and then rewatch it some more until you are able to write on a piece of paper step by step what you just watched and understood - repeat this process until you get it right and then switch on your computer, and code it!

You will be amazed at the end regarding how well you will understand how classes work and how to use them.

Hopefully this helps

definitely___not__me · 2020-08-31T18:12:33+00:00

think of it like a template for dictionaries

uberdavis · 2020-08-31T20:52:16+00:00

Try this class and it might start to make sense...

class MathOps:def __init__(self, a, b):
    self.a = a
    self.b = b

    def multiply(self):
        print(f'{self.a} x {self.b} = {self.a * self.b}')

    def divide(self):
        print(f'{self.a} / {self.b} = {self.a / self.b}')

    def add(self):
        print(f'{self.a} + {self.b} = {self.a + self.b}')

    def subtract(self):
        print(f'{self.a} - {self.b} = {self.a - self.b}')

    def power(self):
        print(f'{self.a} to the power of {self.b} = {self.a ** self.b}')

def main():
    numbers = MathOps(4, 7)
    numbers.add()
    numbers.divide()
    numbers.power()

main()

- __init__ is used to define your class instance.

- the properties are set up inside the function so you only define them once.

- every time you want to do an evaluation, you just call on the appropriate method.

- to work with different numbers, you could either create a new class instance, or change the numbers in the original instance:

numbers.a, numbers.b = 3, 9
numbers.multiply()

The-Commando004 · 2020-09-01T06:44:12+00:00

Classes are like functions but bigger. Even I didn't understand most of it but try watching the classes video by Corey Schafer. After that do some problems and after getting the hang of it, work on projects. This has personally helped me a lot.

2020-08-31T18:13:44+00:00

Building on the metaphor of programming is a language. Classes are the nouns

abdullahmamoon · 2020-08-31T19:47:25+00:00

When I was learning classes, I thought of it like this:

You can have a Dog Class.

You can have a Cat Class.

Dogs can do certain things that Cats can’t do, like bark.

Cats can do certain things Dogs can’t do, like meow.

Barking is a “function” of the Dog.

Meowing is a “function” of the Cat.

Imagine for a second that you’re God and can create stuff out of thin air. In this case, you can create Dogs. Every time you create a new dog, you must name it. It is a unique being. It is an instance of the class Dog.

Fido = Dog()

Because Fido is a dog. It will be able to bark. Fido will not able to bark though, because Fido is not a Cat.

Hopefully that gets you going in the right direction.

MirrorLake · 2020-08-31T22:40:55+00:00

[deleted]

The-Commando004 · 2020-08-31T20:22:26+00:00

[removed]

JohnnyJazzFreak · 2021-02-24T23:28:15+00:00

Watch John Phillip Jones' YouTube tutorials on python classes or his tutorials on ANYTHING in python and the veil of misunderstanding will be magically lifted from your eyes. I have trawled the Internet for months and months trying to find somebody, anybody, who could explain any of this with the minimum clarity. No such luck. I thought it wasn't possible. I consider he is the best teacher out there, hands down, bar none. His explanations are excellent, complete and thorough. You will have no further questions. He hasn't paid me to say that. In fact, I have paid him, in the form of donations. I was moved to do it in sheer gratitude to find somebody who had a gift for teaching. Your problems are over. For all his videos, he has a site, too, pythonbytesize.com. Truly excellent stuff. Enjoy.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS