Python Classes and Objects
Python is an object-oriented programming language. Classes provide a way to define blueprints to create objects. Objects have associated methods (functions belonging to them) and data attributes.
1. Defining a Class:
Use the `class` keyword and convention is UpperCamelCase names:
class Dog: # name “Dog” using CamelCase since refers to object type/class
def __init__(self, name, breed): # __init__ constructor initializer (like in other OOP where C++/Java would declare as methods that are executed when new objects instantiated during assignment unlike python's "def" which unlike most methods then functions at time before object has state rather than defining its expected initialization behavior at instantiation later within the `Dog()` example where class instantiation needs state/initialization values and can access attributes that haven't been assigned despite that non-sequential flow). self refers current object under manipulation, which means after valid parameters passed by initialization call for object then next statements after class definition assuming `name`,`breed` provided and converted as expected during that instance instantiation such as by explicit casting where a number remains after implicit str cast elsewhere for math which still suffices within other conditional test (for a bool rather than a TypeError like similar steps previously done by nested Sets where types do not necessarily retain correct behavior if same values present after even seemingly correct int addition with mixed `float`)
self.name = name #Instance attributes (self.name,self.breed) where similar named objects could conflict/cause issues unless fully namespaced if used in other programs importing components with their `classes`, so convention useful within program files containing classes where names matter and also to keep same as much as feasible where naming can convey related semantics via inheritance unless types conflict as example in DateTime sections before with format conversions where same variable produces invalid outputs for reasons related to scope after such ops
self.breed= breed
# any assignments here follow once preceding assignments and validations take place so could raise similar error from tests using incorrect number type conversions or casts or checks of value after implicit `float` result unless cast using integer earlier even with seemingly similar numerical inputs as with set and dictionary math when adding str that must implicitly cast int then and in that way still raise exceptions unlike doing float calculation so any checks assuming numbers only in later ops given context also raise type error then similarly like when assigning float to expected dict of ints
def bark(self): # Method
print ("Woof!")
2. Creating an Object (Instantiation):
New instances instantiated via this method using valid `class Dog:` syntax in effect like other methods invoked after its definition by name like DateTime conversions rather than assuming that instance attribute becomes a method or related behavior with functions/class in Python unless called directly when instantiation can't produce exceptions due to scope unless methods used correctly during these steps to validate parameters where if valid then type of arguments when instantiation and not constructor used in Python to do those checks rather than relying upon implementation behaviour if exceptions possible since same arguments without also confirming types after, by assuming they follow from usage at earlier time such as string with spaces after and assuming trimmed but end up different when tests/validations for both fail, might happen when nested `oop` functions invoke such instances directly unlike standalone simpler illustrative examples.
# instantiation or class method call/instantiation example like math/datetime previously after it has state even though python handles those differently unlike C++ where instantiation creates instance/new instance unlike definition which has no internal value and may raise some runtime exception for this usage as a standalone case outside exception handling unless explicit return/exit before.
my_dog1= Dog("Buddy", "Golden Retriever") # name: "Buddy”, breed : Golden Retriever # Create instances of objects
my_dog2= Dog("Max","German Shepherd")
# Accessing object data
print(my_dog1.name) #Buddy (prints name )
print(my_dog2.breed) #German Shepherd
print (my_dog1.bark())
3. Class Variables vs Instance Variables
Instance variables particular object attribute which each has own separate value after object construction/instantiation even using values exactly the same before that class creation function is done with these unlike in cases where no prior assignment like testing set uniqueness where a local `float` can result with same numbers, even for simple sums/calculations, if integer rather than str type checked prior rather than relying on explicit conversions, and given different behaviours during initialization or after modification of types by those operations implicitly rather than with same syntax at time during those tests like Python unlike others requires: whereas set does `==` before identity which matters in cases after dict elements deleted, then lists still could access if element-value types also changed since that modifies output where position would otherwise remain invariant unlike set/dict use despite `len` changing by comparison. If key is string/num where similar ops valid unlike after cast to some tuple then hash behaviour in checks differs due to uniqueness and ordering implied when that conversion done explicitly during later stage which may raise a `TypeError` during nested logic given values same like strings rather than explicit string rather than number cast despite its seeming compatibility if a set done before other ops
Class vars: apply across object instances even after reassignment unless `self` syntax where values shared. Example illustrating instance where if you changed the species later in same block this modifies value globally too but doing an update instead on breed does so locally not globally since the shared data applies differently than to particular instances only rather than across given its scoping
class Dog2:
species = "Canis familiaris" # Class variable
# It has scope only after its value has changed in Python (after class)
def __init__(self, name, breed):
self.name = name
self.breed= breed # Instance Variable
my_dog3=Dog2("Buddy","Golden Retriever")
my_dog4 = Dog2("Maxx","German Sheperd")
print(my_dog3.species) #Canis familiaris
print(my_dog4.species) #Canis familiaris # since it is `class` style var rather than the name-based value given for breed which differs unlike instances where object pointers compared such as after creating identical a/b instances with some list where identity check passes whereas the `is`-test using == might clash
Dog2.species= "Canis lupus" #Modifying class vars affects even later rather than existing ones since shared object-type, class/function attribute by scope not value here unlike previous when assigning for each separately unlike prior instance of nested types changing for initial variable because same shared object during modifications
my_dog5 = Dog2("Jacky","Labrador")
print(my_dog5.species) # Canis lupus