Cheat Sheet on Python Classes and OOP

Encapsulation in OOP conceals the internal state and the implementation of an object from other objects. It can be used for restricting what can be accessed on an object.

In Python, encapsulation with hiding data from others is not so explicitly defined and can be interpreted rather as a convention. It does not have an option to strictly define data being private or protected. However, in Python, you would use the notation of prefixing the name with an underscore (or double underscore) to mark something as nonpublic data. When using the double underscore, name mangling occurs; i.e in a runtime, that variable name is concatenated with the class name.

If you have an __auditLog() method in a device class, the name of the method becomes Device__auditLog(). This is helpful to prevent accidents, where subclasses override methods, and break the internal method calls on a parent class. Still, nothing prevents you from accessing the variable or method, even though, by convention, it is considered private.

class Device:
   def __auditLog(self):
      # log user actions
      pass

   def action(self):
      # perform desired action and log
      (self.__auditLog()     # private methods can typically called only
                             # within the same class

modules, classes or functions directly.

Goes hand in hand with class hierarchy. When a parent class defines a method that needs to be implemented by the child class, the method is considered polymorphic, because the implementation would have its own way of presenting a solution than what the higher-level class proposed.

Polymorphism is present in any setup of an object that can have multiple forms. when a variable or method accepts more than one type of variable, it is polymorphic.

Already discussed in python classes.

Provide all the standard features of object oriented programming.

Capitalize all classes. For example, "class User:" not "class user:".

pass

If you define a class you MUST have at least one statement in the class. If you want the class to do nothing, you can include the pass statement which passes to the next statement without doing anythin. – why???

From Socratica:

class User:
    pass

user1 = User()

Here user1 is an instance of the User class. You can call user1 an object. To attach data to this object we can add some fields like this:

user1.first_name = "John"
user1.last_name = "Cleese"

first_name and last_name are variables. Because first_name and last_name are attached to an object, we call them "fields".

These fields store data specific to user1. As per PEP 8 style guide, you should NOT capitalize fields, and you should use underscores to separate multi_word fields.

objects of a class do NOT neccessarily all have the same fields. For example, look at this:

user1.age = 80
user2.first_name = "Eric"
user2.last_name = "Idle"
user2.songs = 115

If you try to ask for user2.age you will get an error: "AttributeError: 'User' object has no attribute 'age'

Even though user1.age will get you the answer 80.

So, you can use dir(user2) to see what fields it has.

New classes can be defined based on existing classes. When they do they inherit the properties, data, and functionality of the existing class.'

In python you do NOT have to pre-declare instances of objects. They get declared/created the first time you use a class to create a class instance.

Outside of the class, you refer to methods inside the class as class.method i.e. use the "dot" notation.

variables declared inside a class are not private. But by convention only people use _varname for variables intended to be private (i.e. used only within the class or function.

See docs.python.org for detail on classes and methods.

Creating a class means creating a new TYPE of object, not an instance of a type of object.

x = 3 simply creates a new instance of an integer class object, and assigning it to "x". But creating a class is creating a new TYPE.

The new TYPE of object allows new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state.

Data of fields for a class attributes. The combined self, and extra argument (attributes) passed to and from class is called the class signature

These all mean the same thing.

Instance attributes are variables assigned to a particular instance of the class, for example employee1.first_name

They contain data that is unique to each instance. i.e. employee #

act1.first = 'John'
act1.last = 'Cleese'
act1.email = 'jcleese@python.uk'
act1.role = 'Sir Lancalot'
act1.lines = 656

act2.first = 'Michael'
act2.last = 'Palin'
act2.email = 'mpalin@python.uk'
act2.role = 'Sir Galahad'
act1.lines = 412

That is a manual approach. The better way is to use classes properly by creating a 'method' a.k.a. function to do this for us automatically. See 'Methods' below:

These are variables that are related to the class itself and not just a particular instance of the class (in which case they are instance variables… see above). Class variables have the same value across all class instances. i.e. static variables For instance email domain could be a static variable across ALL instances of an employee class for a company.

For example:

print(Pythonite.troupe-name) is the same regardless of actor (for Monty Python)

Methods are really just functions, but functions that are associated with a class. The two major differences between functions and methods:

1. The method is implicitly used for an object for which it is called.
2. The method is accessible to data that is contained within the class.

from tutorialspoint.com

When we create methods within a class, they always receive the class instance as the first argument automatically. This is true on regular methods and on dunder methods.

This first argument is always called "self".

This first argument is always called "self". It is a reference to the new object being created. You could call it anything, but convention is to call it self. After 'self' you can add any other arguments you want the method to accept additional arguments

The additional arguments are optional. If they are added, then you must store these values in fields, using the self. syntax as below:

Class Pythonite:
   def __init__(self, first, last, role, lines):
        # these are the instance attributes, and they only belong to one
        # instance of the object.  (each  object has its own attributes)
        self.first = first
        self.last = last
        self.name = f"{first} {last}"
        self.role = role
        self.email = first.lower()[0] + last.lower() + '@montypython.uk'
        self.lines = lines
        # first[0] is the first letter of the string held in first
        # first.lower() is the string converted to lower case
        # first.lower()[0] is the first letter of the string, lower case

   def method66(self, argument2, argument3)
       self.field2 = argument2
       self.field3 = argument3

   def announce(self):
       print(f"{self.name} has arrived!!!")

   # if no partner is supplied when method is called, announce them as 'guest'
   def announce_partner(self, partner="guest"):
       print(f"{self.name} and {partner} have arrived!!!")

act1 = Pythonite('John', 'Cleese', 'Sir Lancalot', 656)
act2 = Pythonite('Michael', 'Palin', 'Sir Galahad', 412)
act3 = Pythonite('Eric', 'Idle', 'Sir Robin', 489)

spouse = "Janet"
act1.announce_partner(spouse)
act3.announce_partner()
act2.announce()

# will print
# John Cleese  and Janet have arrived!!!
# Eric Idle  and guest have arrived!!!
# Michael Palin has arrived!!!

In addition, if you want those fields to have default values do this:

def method77(self, argument2=3.1415, argument3=2.71828)
    self.field2 = argument2
    self.field3 = argument3

In which case you can call act1.method66() or act1.method66(3.14, 2.72)

Special care must be taken if the argument is a muttable object in python. That is, best to direclty set them inside the method. For example, an array is a mutable object, so for arrays as arguments do this:

def method66(self, argument2=None, argument3=None)
    if argument2 is None:
       argument2 = []
    if argument3 is None:
       argument3 = []
    self.field2 = argument2
    self.field3 = argument3

class ABC : 
    def method_abc (self): 
        print("I am in method_abc of ABC class. ") 

class_ref = ABC() # object of ABC class 
class_ref.method_abc()

output: I am in method_abc of ABC class.

__init__
__self__
__str__
__lt__
__gt__
__eq__
__add__
__dict__

In python, using leading and trailing double underscores is the naming conventions for indicating a variable is meant to be private.

Dunder or magic methods in Python are special methods that are defined with double underscores (or 'dunders'), such as init, iter, str, dict, weakref, __lt___

A class supports inheritance, which is the ability for deriving new classes based on existing classes.. The new class is called the child class while the inherited class is called the parent class

if you have a list, say nums = [1, 2, 3] and run dir(nums) you will see the __iter__ but you won't see the __next__ because lists by themselves are iterable, but are NOT iterors. That is why if you try to run the next function on nums you will get an error saying: "TypeError: 'list' object is not an iterator" i.e. print(next(nums))

Now if you take that list and create a new object using iter, like so: i_nums = iter(nums) tAnd then you run dir(i_nums) you will see BOTH the __iter__ and the __next__ methods, so i_nums is an iterator. You can then use print(next(i_nums))

To avoid getting a ExceptionError: StopIteration when you run out of instances and still try to run next() on it, you use this common while contruct:

while True:
   try:
      item = next(i_nums)
      print(item)
   except StopIteration:
      break

For example, "class User:" not "class user:".

pass

If you define a class you MUST have at least one statement in the class. If you want the class to do nothing, you can include the pass statement which passes to the next statement without doing anythin. – why???

From Socratica:

class User:
    pass

user1 = User()

In the above example, user1 is an instance of the User class. You can call user1 an object. To attach data to this object we can add some fields like this

user1.first_name = "John"
user1.last_name = "Cleese"

first_name and last_name are variables Because first_name and last_name are attached to an object, we call them "fields". These are also called attributes, or instance variables.

objects of a class do NOT neccessarily all have the same fields. For example, look at this:

user1.age = 80
user2.first_name = "Eric"
user2.last_name = "Idle"
user2.songs = 115

If you try to ask for user2.age you will get an error: "AttributeError: 'User' object has no attribute 'age'

Even though user1.age will get you the answer 80.

So, you can use dir(user1) or dir(user2) to see what fields it each object has, and what methods are available to that class.

dir() without arguments returns a list of names in the current local scope.

dir(class)

dir(string)

dir(anyobject)

A nicer alterative to dir() is see() but you have to import xx first Another alternative is inspect() … import inspect first.

These fields store data specific to user1. As per PEP 8 style guide, you should NOT capitalize fields, and you should use underscores to separate multi_word fields.

import datetime

class User:
  ''' this docstring will be displayed if one issues help(User).
  The class has two methods, init and age. '''
    def __init__(self, full_name, birthday):
        self.name = full_name
        self.birthday = birthday
      #+ can store the value stored in the argument 'birthday' in a
      #+  field called birthday.
      #+ so be careful when coding.  The second 'birthday' in that line is
      #+ the value provided when you create a new instance of the object
      #+ the first 'birthday' is the name of the field where we will store
      #+ this provided value.

      #+ Expanding the init method, we can extract first and last names
        name_pieces = full_name.split(" ")
      #+ this will store strings split on spaces into an array.
        self.first_name = name_pieces[0]
        self.last_name = name_pieces[-1]  #+ just look at the last string
      #+ self.last_name = name_pieces[1]   #+ would give you the second string
      #+ which might be an initial, and not the last name

      #+ Note that we can create variables in the method, but they exist
      #+ only inside the method and are killed when the method exits.
      #+ i.e. first_name = name_pieces[0] would NOT assign anythying to the
      #+ object.  The correct syntax is self.firstname = name_pieces[0]

    def age(self):
       ''' Return the age of the user in years. '''
       yyyy = init(self.birthday[0:4])
       mm = init(self.birthday[4:6])
       dd = init(self.birthday[6:8])
       dob = datetime.date(yyyy, mm, dd)
       age_in_days = (today - dob).days
       age_in_years = age_in_days / 365
       return int(age_in_years)

Now we can create an object, let's call it 'user':

user = User("Michael Palin", 19430505)
print(user.age())  #+ will print 80 if you run  this in Nov, 2019
help(User) to see all sorts of additional info to the docstrings you added.

def function_name ( arg1, arg2, …) : …… #+ function body ……

   >>> class A(object):
...     x = 1
...
>>> class B(A):
...     pass
...
>>> class C(A):
...     pass
...
>>> print A.x, B.x, C.x
1 1 1

Makes sense.

>>> B.x = 2
>>> print A.x, B.x, C.x
1 2 1

Yup, again as expected.

>>> A.x = 3
>>> print A.x, B.x, C.x
3 2 3

What the $%#!&?? We only changed A.x. Why did C.x change too?

In Python, class variables are internally handled as dictionaries and follow what is often referred to as Method Resolution Order (MRO).

Since the attribute x is not found in class C, it will be looked up in its base classes (only A in the above example, although Python supports multiple inheritances).

In other words, C doesn’t have its own x property, independent of A. Thus, references to C.x are in fact references to A.x. This causes a Python problem unless it’s handled properly.