Python constructors, instance variables and encapsulation

• Constructors: __init__, self, default and parameterized, files 123 to 126
• One object per call, input inside a constructor, and a calculator, files 127 to 130
• Global, instance and local variables, file 131
• Encapsulation and a plain class, files 132 and 133
• The password moves into a .env file, file 134
• Private data behind a method: the bank, files 135 and 136
• Public, protected and private, and pass, files 137 and 138
• Tasks and announcements: a certification, no class on Sunday, what is left in Python

Last class started object-oriented programming with classes and objects, files 121 and 122, and this class went on to the constructor. First a recap: a class is like a blueprint, a blueprint to create something, and an object is an instance of the class.

A class without a constructor: file 123. The class keyword, the name of the class, and a colon; this is Python, so no curly braces. model = None is an attribute, because in Python there is nothing called null, as the instructor said: it only has None. And there is no new keyword: you just call the class.

class MobilePhone:
    model = None

    def talk():
        print("Hello")


ipone = MobilePhone()
ipone.model = "iphone 18 Pro Max"
ipone.talk()

Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/02_Construtor/123_Create_Class.py", line 10, in <module>
    ipone.talk()
TypeError: MobilePhone.talk() takes 0 positional arguments but 1 was given

Is model a function? Not a function, the instructor told a learner: it is a property, an attribute you can access directly, while talk is the function, the behaviour. Line 9 sets the attribute from outside the class.

With self added on line 4, file 123 runs:

class MobilePhone:
    model = None

    def talk(self):
        print("Hello")


ipone = MobilePhone()
ipone.model = "iphone 18 Pro Max"
ipone.talk()

Hello

The constructor: file 124.

class MobilePhone:
    model = None

    def __init__(self):
        print("I will be called, when obj is created!")

    def talk(self):
        print("Normal F(n)")

iphone = MobilePhone()

I will be called, when obj is created!

Line 10 only builds an object, yet the file prints. How did this output come, the instructor asked the class:

Default and parameterized: files 125 and 126. A default constructor has no parameters, no arguments, as the instructor put it: only self.

class Dog:
     # Attributes - Instance variables | Data variables
    name = None
    breed = None
    height = None
    weight = None
    race = None

    def __init__(self):  # Default C - No Parameter
        print("Hi")

It prints nothing: the file defines the class and never builds a Dog, so the constructor never runs. Build two dogs and print their names, and the constructor runs twice, once per object, while both names stay None. A default constructor does not set the value, as the instructor said:

class Dog:
     # Attributes - Instance variables | Data variables
    name = None
    breed = None
    height = None
    weight = None
    race = None

    def __init__(self):  # Default C - No Parameter
        print("Hi")


dog1 = Dog()
dog2 = Dog()
print(dog1.name, dog2.name)

Hi
Hi
None None

A parameterized constructor takes values as well. The first argument is always self; in Python every method's first argument is self, as the instructor said, and self.name lets the constructor set the attribute to whatever value is given:

class Dog:
     # Attributes - Instance variables | Data variables
    name = None
    breed = None
    height = None
    weight = None
    race = None


    def __init__(self,nameGiven, breedGiven):
        print("Param C")
        self.name = nameGiven
        self.breed = breedGiven

    def bark(self):
        print("Barking! -> ",self.name)


    def talk(self):
        print("talking")

chow = Dog("chow","mastiff")
chow.bark()

desi = Dog("rancho","desi")
desi.bark()

# This will not call the Default PARAM, we don't have defalt c
straydog = Dog()

Param C
Barking! ->  chow
Param C
Barking! ->  rancho
Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/02_Construtor/126_Param_Const.py", line 29, in <module>
    straydog = Dog()
               ^^^^^
TypeError: Dog.__init__() missing 2 required positional arguments: 'nameGiven' and 'breedGiven'

• Line 22 passes "chow" and "mastiff", so for this dog self.name is chow and self.breed mastiff. The figure at the top of this section follows that call step by step.
• Line 25 builds a second dog, rancho, of the desi breed, an Indian breed. Each dog barks its own name, because bark() prints self.name.
• Line 29 calls Dog() with nothing. The comment on line 28 says it will not call a default constructor, because the class does not have one, and the instructor told the class it could ignore that line. Run, the line does more than skip a constructor: Python stops the file there with a TypeError, because __init__ needs both values. Put line 29 behind a # and the file ends cleanly after the same four lines.

It is very similar to Java, the instructor said. A learner asked whether a default constructor is mandatory:

Two objects, two names: file 127. IQ in the file name means interview question, as the instructor told a learner who asked. Work out the output before you open the answer; it was the question to the class:

class Dog:
    name = None
    breed = None
    def __init__(self,nameGiven):
        self.name = nameGiven
    def printName(self):
        print(self.name)

chow_ref = Dog("bobby")
mow_ref = Dog("ruks")

chow_ref.printName()
mow_ref.printName()

bobby
ruks

On the iPad, the instructor drew it as memory: two objects are created, each with its own attributes and behaviour, and each with a different reference. When line 9 passes "bobby", it goes to nameGiven and from there to self.name, so for that object self.name is bobby; line 10 does the same with "ruks". Self becomes whichever object you are asking from, as the instructor put it.

The first run in class printed the calls, and None came out as well:

class Dog:
    name = None
    breed = None
    def __init__(self,nameGiven):
        self.name = nameGiven
    def printName(self):
        print(self.name)

chow_ref = Dog("bobby")
mow_ref = Dog("ruks")

print(chow_ref.printName())
print(mow_ref.printName())

bobby
None
ruks
None

That None is the return value. printName() prints by itself and does not return anything, so print() prints the nothing it got back. You do not have to print those, the instructor said: you just have to call them.

Input inside a constructor: file 128. Can we take a user input too? Absolutely we can, the instructor said: in the constructor itself, with input(). Run it via the command, the instructor said, so this one ran in a terminal for these notes, with the keys typed one at a time:

class Person:
    name = None
    age = None
    phone = None
    occupation = None

    def __init__(self):
        print("Let's take the user input, Please share the name,age,phone,occ")
        self.name = input("Enter the name\n")
        self.age = input("Enter the age\n")
        self.phone = input("Enter the Phone\n")
        self.occupation = input("Enter the occupation\n")

    def display_values(self):
        print("Name is ", self.name, "Age is ", self.age, "Phone is", self.phone, "occupation", self.occupation)

amit = Person()
amit.display_values()

Let's take the user input, Please share the name,age,phone,occ
Enter the name
Amit
Enter the age
30
Enter the Phone
999
Enter the occupation
QA
Name is  Amit Age is  30 Phone is 999 occupation QA

Each prompt ends in \n, so every answer goes on the line below it. The four answers are the example ones from the README notes; in class, the instructor typed other answers.

A calculator: the other file 128. A real example: a Calc class with a and b set to None, a default constructor that prints DC, and four methods that take self, a and b and return the result.

class Calc:
    a = None
    b = None

    def __init__(self):
        print("DC")

    def sum(self, a, b):
        return a+b

    def sub(self, a, b):
        return a - b

    def mul(self, a, b):
        return a * b

    def div(self, a, b):
        return a / b

a = float(input("Enter the value of a"))
b = float(input("Enter the value of b"))

object_ref = Calc()

output_sum = object_ref.sum(a, b)
output_sub = object_ref.sub(a, b)
output_mul = object_ref.mul(a, b)
output_div = object_ref.div(a, b)
print(output_sum, output_sub, output_mul, output_div)

It cannot be run directly, the instructor said, as this does not support it: type python, drag the file into the terminal, and run it there. With 10 and 10, the values typed in class:

Enter the value of a10
Enter the value of b10
DC
20.0 0.0 100.0 1.0

• 10 plus 10 is 20, the instructor read out, then pointed to the subtraction, the multiplication and the division.
• DC comes after both inputs, because the object is built only on line 23.
• float() turns each answer into a float, which is why every result ends in .0.

There is no file 129: both input programs are numbered 128. Three questions from learners came up here:

• Why initialize an attribute with None? Without a value it is not a statement in Python, the instructor said: you have to initialize it at least with None.
• Can it start at zero instead? Zero is a number, so it becomes a number, the instructor said. If you do not want any data type, None is a good option.
• Why do methods that are not constructors take self? So that they can access the attributes, the instructor said: every method has self as its first parameter.

Same or different: file 130. One more real example, a Baby class:

class Baby:
    name : None

    def __init__(self, nameGiven):
        self.name = nameGiven

    def printName(self):
        print(self.name)


b = Baby("gugu")
b2 = Baby("sema")
b.printName()
b2.printName()

gugu
sema

Will the two print the same or different, the instructor asked? Different: each object has its own name.

class Baby:
    name : None

    def __init__(self, nameGiven):
        self.name = nameGiven

    def printName(self):
        print(self.name)


b = Baby("gugu")
b2 = Baby("sema")
b.printName()
b2.printName()
print(Baby.__annotations__)
print(Baby.name)

gugu
sema
{'name': None}
Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/02_Construtor/130_REAL.py", line 16, in <module>
    print(Baby.name)
          ^^^^^^^^^
AttributeError: type object 'Baby' has no attribute 'name'

Can we define a data type in Python, as in TypeScript, a learner asked? We can, the instructor said. Line 2 of file 130 is one: an annotation is how Python writes a type.

File 131 puts three kinds of variable side by side. Outside the class a variable is global, within the class it is an instance variable, and within a function it is local, as the instructor put it: G for global, I for instance and L for local.

g = 10 # Global

class Person:
    i = 11 # Instance, Class , Attribute...property
    def print_infor(self):
        l = 10 # local l varaible
        print(self.l)

    def talk(self):
        print(self.i)
        print(g)

It prints nothing: the file defines the class, builds no object and calls nothing. What is the advantage of each, the instructor asked:

With an object built and both methods called, talk() works and print_infor() stops:

g = 10 # Global

class Person:
    i = 11 # Instance, Class , Attribute...property
    def print_infor(self):
        l = 10 # local l varaible
        print(self.l)

    def talk(self):
        print(self.i)
        print(g)


p = Person()
p.talk()
p.print_infor()

11
10
Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/03_Instance_Variables/131_IV.py", line 16, in <module>
    p.print_infor()
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/03_Instance_Variables/131_IV.py", line 7, in print_infor
    print(self.l)
          ^^^^^^
AttributeError: 'Person' object has no attribute 'l'

g = 10 # Global

class Person:
    i = 11 # Instance, Class , Attribute...property
    def print_infor(self):
        l = 10 # local l varaible
        print(l)

    def talk(self):
        print(self.i)
        print(g)


p = Person()
p.talk()
p.print_infor()

11
10
10

Next, encapsulation, and a difference the instructor asked the class not to confuse: encapsulation versus abstraction. Both of them are hiding, but they hide different things, the instructor said. Encapsulation hides the instance variables, the data members, from the outside: they are not allowed outside, only in the presence of a behaviour, a method. Encapsulation happens within the class, and abstraction happens between classes.

Then a 10-minute break, with a task for it:

The deck's four points open and close with these two:

Bind the data variables with the methods.

Wrapping or binding the instance variables / data variables with the methods - Encapsulation.

In between, it says that the instance variables, the data variables, can be accessed only by the methods, and that a method is a def function within the class. How do you hide them? A normal variable is public by default, the instructor said; with one underscore it becomes protected, and with two underscores, private.

A normal class: file 132. This is not an encapsulation example, just a normal class, as the instructor said. Nothing is marked, so everything is public, and everyone can access it. The o_ at the start of the parameter names marks a value given by the user.

class Car:
    name: None
    make: None
    model: None

    def __init__(self, o_name, o_make, o_model):
        self.name = o_name
        self.make = o_make
        self.model = o_model

    def start_engine(self):
        print("Starting a car with the name " + self.name)
        print("Starting a car with the make " + self.make)
        print("Starting a car with the model " + self.model)



lambo = Car("Lambo", "V6", "2023")
lambo.start_engine()

mg_hector = Car("Hector","1.5+ Turbo","2024")
mg_hector.start_engine()

Starting a car with the name Lambo
Starting a car with the make V6
Starting a car with the model 2023
Starting a car with the name Hector
Starting a car with the make 1.5+ Turbo
Starting a car with the model 2024

Lines 2 to 4 use the same colon as file 130: annotations, not attributes. Here, too, the constructor sets every value through self.

Without encapsulation: file 133. A class for the VWO login page, as the instructor put it. The constructor keeps the email and the password as instance variables, and login_confirm() compares them with the values written on line 7, which are masked here.

class VWOLoginPage:
    def __init__(self,email_arg,password_arg):
        self.email = email_arg
        self.password = password_arg

    def login_confirm(self):
        if self.email == "<email>" and self.password == "<password>":
            print("Allowed to Login")
        else:
            print("Login Failed")


email = input("Enter the vwo login email ")
password = input("Enter the vwo login password ")

vwo_object_ref = VWOLoginPage(email,password)
vwo_object_ref.login_confirm()

This file was not run for these notes. In class, the email and password on line 7 printed Allowed to Login, and a wrong email printed Login Failed. But the problem, the instructor said, is that the values are hardcoded.

Without encapsulation, but secure, as the instructor put it: everything stays the same, except that the values the check expects move out of the code into a .env file. Reading that file needs a utility you install from the terminal; the README notes give the command as pip install python-dotenv. Then keep a .env file with the username and the password in it. This is much more secure, the instructor said, because now there is no hardcoded value. Call load_dotenv(), and os.getenv(), from the operating system module, fetches each value.

from dotenv import load_dotenv
import os
class VWOLoginPage:

    def __init__(self, email_arg, password_arg):

        self.email = email_arg
        self.password = password_arg

    def login_confirm(self):
        load_dotenv()
        if self.email == os.getenv("USERNAME") and self.password == os.getenv("PASSWORD"):
            print("Allowed, Login Sucess")
        else:
            print("Login Failed")


email = input("Enter the vwo login email ")
password = input("Enter the vwo login password ")

vwo_object_ref = VWOLoginPage(email,password)
vwo_object_ref.login_confirm()
print(vwo_object_ref.password)

print(os.name)

You will not commit the .env file. The class added it to .gitignore: password-related things are not going to be pushed, and the file is not going to be uploaded on GitHub, the instructor said. What you get instead is .env-sample, with sample values, and you just have to remove the sample, as the instructor put it. The README notes' way: copy .env-sample to .env, and put your own values in the copy.

USERNAME=sample
PASSWORD=sample_password

File 134 was not run for these notes either. In class, a wrong email and password failed the login, and yet the password could still be accessed, the instructor said: it reads vwo_object_ref.password from outside the class, and it can, because the attribute is public. This is where encapsulation comes in, the instructor said.

import os
from dotenv import load_dotenv

os.environ["USERNAME"] = "windows-user"   # already set, as Windows sets it
load_dotenv()                             # .env holds USERNAME=sample
print(os.getenv("USERNAME"))
load_dotenv(override=True)
print(os.getenv("USERNAME"))

windows-user
sample

Can you access a public member from outside the class? Absolutely yes, the instructor said. And a private one? Absolutely no. File 135 shows both: it reads a public attribute from outside, then tries a private one on line 19 and stops with an AttributeError. If you want to access a private member, there is only one way, the instructor said: a method of the class, called through the object reference. Two methods of file 135, on lines 11 to 15, print the private value from inside the class.

What error does it throw, a learner asked:

The bank: file 136. The best example, the instructor said, one that gives 100% clarity about encapsulation:

class Bank:

    def __init__(self, account_number, balance):
        self.balance = balance  # public
        self.__account_number = account_number  # Private

    def check_balance(self):
        print(self.balance)

    def deposit(self, amount):
        self.balance = self.balance + amount

    def show_me_account_number(self, is_auth):
        if is_auth == True:
            print(self.__account_number)
        else:
            print("Not Allowed!")


icici = Bank(9876543210, 100)
icici.deposit(100)
icici.check_balance()
# print(icici.__account_number)
# if you are cashier you can see the a/c becoz of the ecapsulation.
icici.show_me_account_number(True)

200
9876543210

• The balance is public, so everyone can see it, as the instructor put it. deposit() adds 100 to the starting 100, and line 22 prints 200.
• The account number is private: two underscores. Only you can see it, or probably the cashier, the instructor said, and the comment on line 24 says the same of the code.
• show_me_account_number() is a public method, and it can read the private variable because it is inside the class. That is encapsulation: within the class, this method can access a data variable that is private.

Line 23, switched on, tries the account number from outside the class, and stops:

class Bank:

    def __init__(self, account_number, balance):
        self.balance = balance  # public
        self.__account_number = account_number  # Private

    def check_balance(self):
        print(self.balance)

    def deposit(self, amount):
        self.balance = self.balance + amount

    def show_me_account_number(self, is_auth):
        if is_auth == True:
            print(self.__account_number)
        else:
            print("Not Allowed!")


icici = Bank(9876543210, 100)
icici.deposit(100)
icici.check_balance()
print(icici.__account_number)
# if you are cashier you can see the a/c becoz of the ecapsulation.
icici.show_me_account_number(True)

200
Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/04_Encapsulation/136_Ecap.py", line 23, in <module>
    print(icici.__account_number)
          ^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'Bank' object has no attribute '__account_number'. Did you mean: '_Bank__account_number'?

The deck's three lines on the access levels:

Public: Variable - Don't Mention anything - anyone can access.

Protected, one underscore: Members are intended for internal use within the class and its subclasses.

Private, two underscores: Members are only accessible within the class they are defined in.

File 137 puts one member at each level into a Home class, with one method that reads the private member and a private method of its own. In a nutshell, the instructor said, remember this: private variables will be accessible only through a public function.

A test example: file 138. A test case running on Chrome: the driver, Chrome, is public in nature, the configuration, a stage, is protected, and the API key is private, as the instructor described it.

class TestExample:
    def __init__(self):
        self.driver = "Chrome"
        self._config = "STAG"
        self.__api__key = "ABC12345"

    def show(self):
        print(f"Driver: {self.driver}")
        print(f"Config: {self._config}")
        print(f"API Key: {self.__api__key}")


    def __private_method1(self):
        pass

    def __private_method2(self):
        pass

    def work(self):
        self.__private_method1()
        self.__private_method2()


obj = TestExample()
obj.show()
obj.work()


# Access levels:
# print(obj.driver)          # ✅ Public - accessible
# print(obj._config)         # ⚠️ Protected - accessible but discouraged
# print(obj.__api__key)     # ❌ Private - AttributeError

Driver: Chrome
Config: STAG
API Key: ABC12345

• show() reads all three, because it is inside the class.
• __private_method1 and __private_method2 are private methods, and work(), a normal method, can call them: absolutely yes, the instructor said.
• Lines 30 to 32 note what outside code gets. Switched on:

class TestExample:
    def __init__(self):
        self.driver = "Chrome"
        self._config = "STAG"
        self.__api__key = "ABC12345"

    def show(self):
        print(f"Driver: {self.driver}")
        print(f"Config: {self._config}")
        print(f"API Key: {self.__api__key}")


    def __private_method1(self):
        pass

    def __private_method2(self):
        pass

    def work(self):
        self.__private_method1()
        self.__private_method2()


obj = TestExample()
obj.show()
obj.work()


# Access levels:
print(obj.driver)          # ✅ Public - accessible
print(obj._config)         # ⚠️ Protected - accessible but discouraged
print(obj.__api__key)     # ❌ Private - AttributeError

Driver: Chrome
Config: STAG
API Key: ABC12345
Chrome
STAG
Traceback (most recent call last):
  File "chapter_15_Python_PyTest/ex_18_OOPs_Python/04_Encapsulation/138_PPP.py", line 32, in <module>
    print(obj.__api__key)     # ❌ Private - AttributeError
          ^^^^^^^^^^^^^^
AttributeError: 'TestExample' object has no attribute '__api__key'

The configuration is accessible, but discouraged, the instructor said, and the private one is not available at all.

And the difference between protected and private? Private is within the class only, the instructor said; protected is within the package, the same folder, where several classes can exist; and public is everywhere. Of the three, only the double underscore changes what Python does, by renaming the member, as the runs above show.

• A certification, now. If you have not done AI Fluency: Framework & Foundations, do it first: watch the 52-minute video and get the certification. If you have done it, pick any other certification from the list that you have not done. Then put it on LinkedIn, and you can tag the instructor. The instructor wanted it done right now.
• Not Claude Code in Action. The batch had not done that one, the instructor thought, and said it would come off the list, marked red.
• Recordings. They are already in the SDET Club. Is there a recording for all 10, a learner asked? For most of them, the instructor thought. Meeti was asked to put an announcement and the certification information in the SDET Club, and, if possible, to add the recording links to the sheet.
• The sheet. The deck's 7 November section links the certification sheet. Its first tab lists ten free Anthropic courses with a status for each.
• No class on Sunday, the next day, for Diwali. Enjoy it, the instructor said.
• The coming week. There will be a class, so do not go, as the instructor put it. It might be a certification class, and the instructor will let you know: the plan is to pick one or two certifications from the list and try to do them, such as AI capabilities, subagents or the Claude API. After Diwali, the instructor said, the batch will target subagents, building with Claude, the advanced Model Context Protocol course and AI capabilities, and more. The sheet names them Introduction to Subagents, Building with the Claude API, Model Context Protocol: Advanced Topics, and AI Capabilities and Limitations.
• What is left in Python: the rest of OOP, then pytest. After that come CrewAI, DeepEval, LangChain and LangGraph. Can DeepEval come first, a learner asked? It can, after CrewAI, the instructor said: CrewAI first, then DeepEval, then LangChain and LangGraph.
• GitHub Copilot. Is there a free certification for it, a learner asked? As of now, no, the instructor said.