13 - Encapsulation & Static Keyword

Write OOP classes to handle the following scenarios:

• A user can create and view 2D coordinates
• A user can find out the distance between 2 coordinates
• A user can find find the distance of a coordinate from origin
• A user can check if a point lies on a given line
• A user can find the distance between a given 2D point and a given line

Example 1

Explanation

• Defines a Point class with x and y coordinates, including methods to display the point, calculate Euclidean distance between two points, and distance from origin
• Implements a Line class representing linear equations in form Ax + By + C = 0 with methods to check if a point lies on the line and calculate shortest distance from a point to the line
• Uses special methods like init and str for object initialization and string representation
• The euclidean_distance method calculates straight-line distance using the Pythagorean theorem
• Both classes store coordinate data and provide geometric calculations for points and lines in 2D space

Example 2

Explanation

• Creates two Point objects with coordinates (1,2) and (3,4) respectively
• Creates a Line object with parameters (3,4,5) - likely slope, y-intercept, and possibly x-coordinate
• Calls print() function on each object which will display their string representations
• Uses Point and Line classes from an imported graphics or geometry module
• Output shows the textual representation of each geometric object's properties

Output

Example 3

Explanation

• Calls the euclidean_distance method on object p1 to calculate the straight-line distance to point p2
• Uses the mathematical formula √[(x₂-x₁)² + (y₂-y₁)² + (z₂-z₁)²] for 3D space or similar for lower dimensions
• Returns a single floating-point number representing the distance between the two points
• Both p1 and p2 must be point objects with coordinate attributes (x, y, z)
• No side effects occur; this is a read-only calculation that doesn't modify either point object

Output

Example 4

Explanation

• Calls the distance_from_origin method on object p1 to calculate its distance from the coordinate origin (0,0)
• Uses the Euclidean distance formula to compute the straight-line distance between p1's coordinates and the origin
• Returns a numerical value representing the calculated distance as a float or integer
• Method likely uses attributes like p1.x and p1.y internally to perform the calculation
• Side effect is returning the computed distance value without modifying the original p1 object

Output

Example 5

Explanation

• Creates a Line object with coefficients (1,1,-2) representing equation x+y-2=0 and a Point object at coordinates (1,1)
• Prints string representations of both the line and point objects
• Checks if the first point lies on the line and calculates the shortest distance from the point to the line
• Tests the same operations with a second point at (1,5) that doesn't lie on the line
• Outputs boolean values for point-on-line tests and numerical distances for shortest distances

Output

How objects access attributes

Example 6

Explanation

• Defines a Person class with constructor that stores name and country attributes
• Includes a greet method that prints different greetings based on the person's country
• Uses conditional logic to check if country equals 'india' and prints 'Namaste' or 'Hello' accordingly
• Creates object instances that can call the greet method to display personalized messages
• Has no direct output when defined, but will print greetings when greet() is called on instances

Example 7

Explanation

• Creates a Person object instance with name 'Madhu' and country 'India' using the Person constructor/class
• The Person class is likely defined elsewhere with attributes for storing personal information like name and location
• This line initializes an object that can later have its attributes accessed through dot notation like p.name or p.country
• No immediate output or side effects occur - just object creation
• The variable p now holds a reference to this Person object for future attribute access or method calls

Example 8

Explanation

• Accesses the name attribute of the object p
• Likely retrieves a string value representing the name of whatever object p refers to
• Commonly used with objects like files, processes, or custom classes that have a name property
• Returns the name value directly without modifying anything else
• If p doesn't have a name attribute, this would raise an AttributeError

Output

Example 9

Explanation

• Calls the greet() method on the object p, which is likely an instance of a class
• This method probably prints a greeting message or returns a welcome string
• The dot notation (p.greet()) is Python's syntax for accessing object methods
• Expected output would be whatever the greet() method is programmed to display
• Side effect depends on the implementation but typically involves printing text or returning a string

Output

Example 10

Explanation

• Attempts to access a gender attribute on an object p that doesn't have this attribute defined
• Will raise an AttributeError exception since the attribute doesn't exist on the object
• Common Python error when trying to access properties that weren't initialized or defined
• Demonstrates Python's strict attribute access behavior - no graceful fallback like some other languages
• Typical debugging scenario when working with object-oriented code and attribute names

Output

Attribute creation from outside of the class

Example 11

Explanation

• Sets the gender attribute of the object p to the string value 'Male'
• This is a simple attribute assignment operation that modifies the object's state
• No functions or APIs are called, just direct attribute setting
• The object p now has its gender property updated to 'Male'
• This change persists in the object until modified again

Example 12

Explanation

• Accesses the gender attribute of the object p
• Likely retrieves a gender value stored in the object's properties
• Commonly used with objects that represent people or entities with demographic attributes
• Returns the gender information as a string or similar data type
• May raise an AttributeError if the gender attribute doesn't exist on object p

Output

Reference Variables

• Reference variables hold the objects
• We can create objects without reference variable as well
• An object can have multiple reference variables
• Assigning a new reference variable to an existing object does not create a new object

Example 13

Explanation

• Creates a Person class with name and gender attributes, then makes two references (p and q) pointing to the same object instance
• The variable p doesn't contain the actual object, but holds a reference/address to where the object exists in memory
• Both p and q point to the exact same object in memory, so they're aliases for the same instance
• No new object is created - both variables reference the identical object created by Person()
• This demonstrates Python's object model where variables are references to objects rather than containers for objects

Example 14

Explanation

• This code prints the memory addresses (identity) of two variables p and q using the id() function
• The id() function returns a unique integer representing the object's location in memory
• It's commonly used to check if two variables reference the same object or different objects
• If both variables have the same id() value, they point to the exact same object in memory
• The output shows two integer values representing where p and q are stored in memory

Output

Example 15

Explanation

• The code prints the name attribute of two objects, p and q, to the console.
• It then changes the name attribute of the object q to "Dadi".
• After the change, it prints the name attribute of q again, showing the updated value.
• The name attribute of p remains unchanged and is printed after the modification of q.

Output

Pass by reference

Example 16

Explanation

• Defines a Person class with an __init__ method to initialize name and gender attributes.
• Implements a greet function that takes a Person object and prints a greeting using the object's attributes.
• Creates an instance of Person named p with the name 'Madhu' and gender 'Male'.
• Calls the greet function with the p object, resulting in the output: "Hi my name is Madhu and I am a Male".

Output

Example 17

Explanation

• Defines a function greet that takes a person object and prints a greeting using the person's name and gender.
• Creates a new Person object p1 with the name 'Dadi' and gender 'Male' inside the greet function.
• Returns the p1 object from the greet function.
• Calls the greet function with a Person object p (name 'Madhu', gender 'Male') and stores the returned object in x.
• Prints the name and gender of the returned Person object x, which will output 'Dadi' and 'Male'.

Output

Example 18

Explanation

• Defines a function greet that takes a person object and prints its memory address and a greeting message including the person's name and gender.
• Uses the id() function to retrieve the unique identifier for the person object and the p object.
• Creates an instance of the Person class with the name 'Madhu' and gender 'Male'.
• Calls the greet function with the p object, which prints the memory address of p and the greeting message.
• Expected output includes the memory address of p and the string "Hi my name is Madhu and I am a Male".

Output

Example 19

Explanation

• Defines a function greet that takes an object person as an argument and modifies its name attribute.
• Uses print(id(person)) to display the memory address of the person object before modification.
• Sets person.name to 'Dadi' and prints a greeting message including the modified name and the gender attribute of the person.
• Creates an instance of Person with initial values 'Madhu' and 'Male', and prints its memory address.
• After calling greet(p), it prints the updated name attribute of the person object, which will now be 'Dadi'.

Output

Object ki mutability

Example 20

Explanation

• Defines a function greet that modifies the name attribute of a person object to 'Dadi' and returns the modified object.
• Creates an instance of Person class with initial name 'Madhu' and gender 'Male', storing it in variable p.
• Prints the memory address (ID) of the original p object.
• Calls the greet function with p, storing the returned object in p1, which is the same object as p.
• Prints the memory address of p1 (same as p) and the updated name attribute of p1, which will output 'Dadi'.

Output

Encapsulation

Encapsulation means hiding internal details of a class and only exposing what’s necessary. It helps to protect important data from being changed directly and keeps the code secure and organized.

Example 21

Explanation

• Defines a class Person with an initializer method __init__ that takes name_input and country_input as parameters.
• The __init__ method assigns the input values to instance variables self.name and self.country.
• Creates two instances of the Person class: p1 with name 'nitish' and country 'india', and p2 with name 'steve' and country 'australia'.
• No output is produced; the code simply initializes objects in memory.

Example 22

Explanation

• Accesses the name attribute of the object p1.
• Assumes p1 is an instance of a class that has a name attribute defined.
• Returns the value stored in the name attribute, which could be a string or other data type.
• If p1 does not have a name attribute, it will raise an AttributeError.

Output

Example 23

Explanation

• Accesses the name attribute of the object p2.
• Assumes p2 is an instance of a class that has a name attribute defined.
• Returns the value stored in the name attribute, which could be a string or other data type.
• If p2 does not have a name attribute, it will raise an AttributeError.

Output

Example 24

Explanation

• Defines an Atm class that simulates basic ATM functionalities like creating a PIN, changing it, checking balance, and withdrawing money.
• The __init__ method initializes the ATM object with a default PIN and balance, and prints the object's memory address.
• The menu method prompts the user for input to navigate through different ATM options and calls the corresponding methods based on user selection.
• The create_pin, change_pin, check_balance, and withdraw methods handle specific functionalities, including user input validation for PINs and balance checks.
• The expected output includes success messages for actions taken, balance information, or error messages for invalid PINs or insufficient funds.

Example 25

Explanation

• Creates a new instance of an ATM class called 'obj'
• Uses the Atm() constructor to initialize the object
• No parameters are passed to the constructor
• This object will have all methods and attributes defined in the Atm class
• The variable 'obj' now references this newly created ATM instance

Output

Example 26

Explanation

• Calls the create_pin() method on the obj instance, which likely generates a new PIN code.
• The method may involve logic to ensure the PIN meets certain criteria (e.g., length, complexity).
• It is expected to modify the state of obj by storing the newly created PIN.
• The output or return value is not specified, but it may indicate success or failure of the PIN creation process.

Output

Example 27

Explanation

• Assigns the string value 'hehehehe' to the balance attribute of the obj object.
• This operation updates or creates the balance attribute if it does not already exist.
• The obj must be an instance of a class that allows dynamic attribute assignment.
• No output is produced, but the state of obj is modified to include the new balance value.

Example 28

Explanation

• Calls the withdraw method on the obj instance, which likely represents an object related to a financial account or resource management.
• The withdraw method typically reduces the balance or available amount in the account by a specified amount, though the amount is not shown in this snippet.
• Expected output may include a change in the account balance, and it may also trigger an error if the withdrawal exceeds the available balance.
• This operation may also involve side effects such as logging the transaction or updating a user interface to reflect the new balance.

Output

Example 29

Explanation

• Defines an Atm class with a constructor that initializes a public pin attribute and a private __balance attribute.
• Contains a private method __menu that prompts the user for actions like creating/changing a pin, checking balance, or withdrawing money.
• Implements methods for creating a pin (create_pin), changing a pin (change_pin), checking balance (check_balance), and withdrawing money (withdraw), each requiring the correct pin for access.
• Uses private attributes (indicated by __) to restrict direct access to the balance, enhancing data encapsulation.
• The expected output includes prompts for user input and messages confirming actions like pin creation, balance checks, or withdrawal success/failure.

Example 30

Explanation

• Creates a new instance of an ATM class called 'obj'
• Uses the Atm() constructor to initialize the object
• No parameters are passed to the constructor
• This object will have all methods and attributes defined in the Atm class
• The variable 'obj' now references this newly created ATM instance

Output

Example 31

Explanation

• Calls the create_pin() method on the obj instance, likely to initialize or set a PIN for the object.
• Directly assigns the string 'hehehe' to the __balance attribute of obj, which is intended to be a private variable due to the double underscore prefix.
• The assignment of a string to __balance may lead to unexpected behavior if __balance is meant to hold a numeric value representing a balance.
• No output is produced from these operations, but the state of obj is modified with a new PIN and a potentially incorrect balance value.

Output

Example 32

Explanation

• Calls the withdraw method on the obj instance, which likely represents an object related to a financial account or resource management.
• The withdraw method typically reduces the balance or available amount in the account by a specified amount, though the amount is not shown in this snippet.
• Expected output may include a change in the account balance, and it may also trigger an error if the withdrawal exceeds the available balance.
• This operation may also involve side effects such as logging the transaction or updating a user interface to reflect the new balance.

Output

Example 33

Explanation

• Accesses the __balance attribute of the obj instance, which is likely a private variable.
• The double underscore prefix suggests name mangling, meaning it is intended to be accessed only within the class.
• If obj has a __balance attribute, it will return its value; otherwise, it may raise an AttributeError.
• This code is typically used to retrieve the current balance in a banking or financial application context.

Output

Example 34

Explanation

• Accesses the private attribute __balance of the object obj, which is likely part of a class related to ATM functionality.
• The double underscore prefix indicates name mangling in Python, making the attribute less accessible from outside the class.
• This code retrieves the current balance value stored in the __balance attribute.
• The expected output is the value of __balance, which represents the amount of money available in the ATM account.

Output

Example 35

Explanation

• Calls the create_pin() method on the obj instance, which likely initializes or sets a PIN for an ATM or banking application.
• Directly modifies the private attribute __balance of the obj instance, setting it to the string 'hehehe', which is unconventional since balances are typically numeric.
• The use of name mangling (with __) indicates that __balance is intended to be a private variable, suggesting encapsulation practices in the class design.
• This code may lead to unexpected behavior or errors later in the program due to the inappropriate data type for a balance.

Output

Example 36

Explanation

• Calls the withdraw method on the obj instance, which likely represents an object related to a financial account or resource management.
• The withdraw method typically reduces the balance or available amount in the account by a specified amount, though the amount is not shown in this snippet.
• Expected output may include a change in the account balance, and it may also trigger an error if the withdrawal exceeds the available balance.
• This operation may also involve side effects such as logging the transaction or updating a user interface to reflect the new balance.

Output

Example 37

Explanation

• Defines an Atm class that simulates an ATM with private attributes and methods for managing a user's pin and balance.
• The constructor (__init__) initializes the ATM object, setting a private balance and printing the object's ID.
• Key methods include create_pin, change_pin, check_balance, and withdraw, which handle user interactions and balance management.
• The private attribute __balance is manipulated through get_balance and set_balance methods to enforce encapsulation.
• The __menu method (not called in the provided code) is designed to guide user actions based on input, but is commented out, meaning the menu functionality is not currently active.

Example 38

Explanation

• Creates a new instance of an ATM class called 'obj'
• Uses the Atm() constructor to initialize the object
• No parameters are passed to the constructor
• This object will have all methods and attributes defined in the Atm class
• The variable 'obj' now references this newly created ATM instance

Output

Example 39

Explanation

• Calls the get_balance method on an object to retrieve current account balance
• Uses dot notation to access a method belonging to the object instance
• Likely returns a numeric value representing available funds or account total
• Method name suggests this is part of a financial or accounting class/interface
• No parameters are passed to the method, so it returns the balance as currently stored

Output

Example 40

Explanation

• Sets the balance attribute of the object 'obj' to 1000
• Uses the set_balance method to modify the object's balance property
• This is a typical setter method for managing account or wallet balances
• The object's internal state is updated to reflect the new balance value
• No return value is produced, this is a void method that modifies the object directly

Example 41

Explanation

• Calls the get_balance method on an object to retrieve current account balance
• Uses dot notation to access a method belonging to the object instance
• Likely returns a numeric value representing available funds or account total
• Method name suggests this is part of a financial or accounting class/interface
• No parameters are passed to the method, so it returns the balance as currently stored

Output

Example 42

Explanation

• Calls the set_balance method on an object with the string 'hehehehe' as argument
• Likely attempts to validate or store this string value as a balance amount
• May raise an error if the input is not a valid numeric balance format
• Could trigger internal validation logic that checks if input matches expected balance patterns
• Side effect depends on implementation but probably updates internal balance state or throws exception

Output

Example 43

Explanation

• Calls the get_balance method on an object to retrieve current account balance
• Uses dot notation to access a method belonging to the object instance
• Likely returns a numeric value representing available funds or account total
• Method name suggests this is part of a financial or accounting class/interface
• No parameters are passed to the method, so it returns the balance as currently stored

Output

Example 44

Explanation

• Creates a Person class with name and gender attributes, then makes three Person objects with different names and genders
• Stores these three Person objects in a list called L
• Prints the entire list showing memory addresses of the objects rather than their contents
• Iterates through the list and prints each person's name and gender attributes
• Output shows object memory locations followed by individual name/gender pairs on separate lines

Output

Example 45

Explanation

• Creates a Person class with name and gender attributes, then makes 3 Person objects with different names and genders
• Stores these 3 Person objects in a dictionary with keys 'p1', 'p2', and 'p3'
• Prints the entire dictionary showing all 3 Person objects stored inside it
• Iterates through the dictionary keys and prints each Person object's name attribute
• Output shows the dictionary representation followed by all 3 names printed on separate lines

Output

Static Variables (vs Instance variables)

Example 46

Explanation

• This code shows comments about object-oriented programming concepts in Python
• It explains the difference between instance variables (that change per object like name and balance) and static/class variables (that remain same like Bank ifsc)
• The comments indicate that instance variables must be defined inside a constructor method
• This is setting up foundational knowledge for creating bank account objects with unique identifiers
• The code suggests a class structure where each customer gets unique ID while sharing common bank information

Example 47

Explanation

• This code defines an ATM class that simulates basic banking operations like creating pins, changing pins, checking balance, and withdrawing money
• The __init__ method is a constructor that initializes instance variables (pin, balance, cid) and prints the object's memory address when an object is created
• The menu method displays a text-based interface for users to choose different ATM operations through input prompts
• Methods like create_pin, change_pin, check_balance, and withdraw handle specific ATM functionalities with input validation using pin checks
• Each method performs actions based on user input and updates the object's state (like balance) or shows information to the user

Example 48

Explanation

• Creates an instance of an Atm class and assigns it to variable c1
• Uses the Atm constructor to initialize a new ATM object
• No parameters are passed to the constructor
• This creates a single ATM instance that can be used to call ATM methods
• The variable c1 now references this ATM object in memory

Output

Example 49

Explanation

• Creates a new instance of an Atm class and assigns it to variable c2
• Uses the Atm constructor to initialize a fresh ATM object
• No parameters are passed to the constructor
• This creates an ATM object that can be used to call ATM methods
• The variable c2 now references this new ATM instance in memory

Output

Example 50

Explanation

• Creates a new instance of an ATM class called 'c3'
• Uses the Atm() constructor to initialize the object
• No parameters are passed to the constructor
• This creates an ATM object that can be used to perform banking operations
• The variable c3 now references this new ATM instance in memory

Output

Example 51

Explanation

• Prints the cid attribute of three objects (c1, c2, c3) to the console
• Uses the print() function to display the value of each object's cid property
• Likely shows unique identifier values assigned to each of the three objects
• The cid attribute probably contains some kind of identifier like an ID number or hash
• Output will display one cid per line, showing the specific identifier values for each object

Output

Example 52

Explanation

• This comment explains that static variables in Python are defined at the class level, outside of any method including the constructor (init)
• Static variables belong to the class itself rather than to any specific instance of the class
• These variables are shared among all instances of the class and maintain their value across all objects
• The constructor (init) is where instance variables are typically initialized for individual object instances
• This approach helps in creating class-level attributes that are consistent across all objects of the class

Example 53

Explanation

• Class Atm defines an ATM system with instance variables for pin, balance, and customer ID, along with static variable counter to track number of accounts
• Constructor __init__ initializes each ATM object with default values, assigns unique customer ID using static counter, and prints object's memory address
• Private methods like __menu, __balance and set_balance control access to sensitive data and provide menu-driven interface for ATM operations
• Public methods handle core ATM functionality including creating/changing pins, checking balance, and withdrawing money with proper validation
• Balance is stored as private variable __balance with getter/setter methods to ensure data integrity and prevent direct access from outside the class

Example 54

Explanation

• Creates three separate instances of an Atm class using the constructor
• Each variable (c1, c2, c3) holds a unique object with its own state and properties
• The Atm() constructor is called three times to initialize three different ATM machines
• Each instance would have independent data and methods when used later in the code
• No output is produced at this stage since we're only creating objects, not calling methods

Output

Example 55

Explanation

• Prints the cid attribute of three objects (c1, c2, c3) to the console
• Uses the print() function to display the value of each object's cid property
• Likely shows unique identifier values assigned to each of the three objects
• The cid attribute probably contains some kind of identifier like an ID number or hash
• Output will display one cid per line, showing the specific identifier values for each object

Output

Example 56

Explanation

• Accesses the counter attribute of the Atm class to retrieve its current value
• This is a class-level attribute that likely tracks the number of ATM instances created
• The counter variable is probably initialized to 0 and incremented each time an ATM object is instantiated
• Returns the integer value representing how many ATM objects have been created so far
• No side effects occur when reading this attribute, it simply returns the stored count value

Output

Example 57

Explanation

• Sets a class attribute named counter on the Atm class to the string value 'hehehe'
• This modifies the Atm class itself rather than creating an instance attribute
• The assignment happens at the class level, so all instances of Atm will share this attribute
• No functions or methods are called, this is a simple attribute assignment
• This changes the class state permanently until overwritten by another assignment

Example 58

Explanation

• Creates a new instance of an ATM class called 'c4'
• Uses the Atm() constructor to initialize the object
• No parameters are passed to the constructor
• This creates an ATM object that can be used to perform banking operations
• The variable c4 now references this new ATM instance in memory

Output

Example 59

Explanation

• This code defines an ATM class with private attributes like balance and pin, and a static counter to track instance IDs
• The constructor (__init__) initializes each ATM object with empty pin, zero balance, and a unique ID from the static counter
• Private methods like __menu, create_pin, change_pin, check_balance, and withdraw handle user interactions and operations
• Getters and setters are used to access and modify the private balance attribute safely
• The menu system guides users through various ATM functions using input validation and conditional logic

Example 60

Explanation

• Creates three separate instances of an Atm class using the constructor
• Each variable (c1, c2, c3) holds a unique object with its own state and properties
• The Atm() constructor is called three times to initialize three different ATM machines
• Each instance would have independent data and methods when used later in the code
• No output is produced at this stage since we're only creating objects, not calling methods

Output

Example 61

Explanation

• Prints the cid attribute of three objects (c1, c2, c3) to the console
• Uses the print() function to display the value of each object's cid property
• Likely shows unique identifier values assigned to each of the three objects
• The cid attribute probably contains some kind of identifier like an ID number or hash
• Output will display one cid per line, showing the specific identifier values for each object

Output

Example 62

Explanation

• This code accesses a private class variable __counter from the Atm class using Python's name mangling feature
• The double underscore prefix (__) in __counter triggers Python's name mangling mechanism that changes the variable name internally
• Name mangling makes the variable harder to access directly from outside the class by prefixing it with _ClassName
• The code demonstrates how to access mangled names using the pattern _ClassName__variable_name
• This reveals the internal counter value that was intended to be private and encapsulated within the class

Output

Static Methods

Example 63

Explanation

• This code defines an ATM class with private attributes like balance and pin, and a static counter to track object creation
• The constructor (__init__) initializes each ATM instance with empty pin, zero balance, and a unique customer ID from the static counter
• Private methods like __menu handle user interactions through input prompts and call other methods based on user choices
• Public methods allow users to create/change pins, check balance, and withdraw money while validating inputs and pin authentication
• Static method get_counter provides access to the class-level counter that tracks how many ATM objects have been created

Example 64

Explanation

• Creates an instance of an Atm class and assigns it to variable c1
• Uses the Atm constructor to initialize a new ATM object
• No parameters are passed to the constructor
• This creates a single ATM instance that can be used to call ATM methods
• The variable c1 now references this ATM object in memory

Output

Example 65

Explanation

• Calls the get_counter() method on the c1 object to retrieve its current counter value
• This is likely a custom class method that returns an integer representing a count
• The operation has no side effects - it only reads and returns the current counter state
• Expected output is the numeric value of the counter stored in the c1 object
• Key API used is the method call syntax .get_counter() on an object instance

Output

Example 66

Explanation

• Calls the get_counter() method on the Atm class to retrieve a counter value
• Likely returns a numeric count or timestamp from an ATM system's internal tracking mechanism
• This is a class method call that doesn't require instance creation since it's accessed directly from the class
• Commonly used to track transaction numbers, session counts, or system metrics in banking applications
• Output would be the current value of whatever counter the ATM system is maintaining internally

Output

###Q1:Count number of instances of a class created in Python?

Example: Say Car is any class.

So after creating above instances. We want to count how many instances are created of Car class.

For above example no of instances = 3.

Write a program for above problem.

Example 67

Explanation

• Creates a Car class with a private class variable __counter that tracks number of instances
• Constructor (__init__) increments the counter each time a new Car object is created
• Defines a class method get_counter that returns the current value of the counter
• Four Car objects are instantiated, causing the counter to increment from 0 to 4
• Prints the final counter value, which is 4, representing the total number of Car instances created

Output

###Q-2: Create a deck of cards class. Internally, the deck of cards should use another class, a card class. Your requirements are:

• The Deck class should have a deal method to deal a single card from the deck
• After a card is dealt, it is removed from the deck.
• There should be a shuffle method which makes sure the deck of cards has all 52 cards and then rearranges them randomly.
• The Card class should have a suit (Hearts, Diamonds, Clubs, Spades) and a value (A,2,3,4,5,6,7,8,9,10,J,Q,K)

Deck Class

• It is class of all possible cards in a deck. Total 52 cards.
• Methods - deal() it will take out one card from the deck of cards.
• Deck of cards should get shuffeled while creating the deck object.
• no of cards remaining in deck - <number> should dsiplay on printing any deck object.

Card class

• It is a class of card
• Atrributes - suit and value
• <suit> of <value> should dsiplay on printing any card object.

Example 68

Explanation

• Creates a card class to represent individual playing cards with suit and value attributes, and a string representation method
• Creates a deck class that initializes a full 52-card deck using list comprehension with all combinations of suits and values
• Implements shuffle method that only works on full decks and uses random.shuffle to reorder cards
• Implements deal method that removes and returns the last card from the deck, with error handling for empty decks
• Prints two dealt cards followed by the remaining card count in the deck after shuffling

Output

Q-3: Find the area of a rectangle.

Approach:

• The class name should be Rectangle.
• The constructor should accept two parameters length and height but you can't pass the values directly to it while creating the constructor. E.g., rectangle = Rectangle(length=10, height=8) <-- you can't do that while creating the instances.
• Create a method called area() which has no parameters.
• Create a method called is_square() which also has no parameters. Return True if the rectangle is a square otherwise return False.
• If you are using a if-else block inside the is_square() method, then use the one-linear syntax.

Example 69

Explanation

• Creates a Rectangle class with length and breadth attributes initialized through __init__
• Uses @classmethod decorator to define a class method property that creates new Rectangle instances
• Calls Rectangle.property(4,4) to create a rectangle with equal length and breadth
• Calculates and prints the area of the rectangle (16) and checks if it's a square (True)
• The class method allows creating objects without directly calling the constructor with different syntax

Output

Q-4: Problem 4

Statement: Write a program that uses datetime module within a class. Enter manufacturing date and expiry date of the product. The program must display the years, months and days that are left for expiry.

Example 70

Explanation

• Creates a Product class that asks user for manufacturing and expiry dates in MM/DD/YYYY format
• Uses datetime.strptime to convert string dates into datetime objects for proper date manipulation
• Implements time_to_expire method that compares current date with expiry date
• Prints "product expired already" if current date is past expiry date
• Shows remaining days until expiration using date subtraction when product is still valid

Output

Q-5: Problem 5

Statement: A university wants to automate their admission process. Students are admitted based on the marks scored in the qualifying exam. A student is identified by student id, age and marks in qualifying exam. Data are valid, if:

• Age is greater than 20
• Marks is between 0 and 100 (both inclusive)

A student qualifies for admission, if

• Age and marks are valid and
• Marks is 65 or more

Write a python program to represent the students seeking admission in the university. The details of student class are given below.

Example 71

Explanation

• Defines a Student class with private attributes for student ID, marks, and age, initialized to None.
• Includes setter methods to assign values to the private attributes and getter methods to retrieve their values.
• Contains validation methods to check if the age is greater than 20 and if marks are within the range of 0 to 100.
• The check_qualification method determines if the student is qualified based on age and marks, returning True if marks are 65 or above.
• Creates an instance of Student, sets its attributes, and prints the student ID, marks, and age, but does not print the qualification result.

Output

###Q-6: Ice-Cream Scoops and Bowl shop

1. Create a class Scoop which has one public property flavor and one private proptery price. Take flavor values during object creation.

2. Create a class Bowl with private prperty scoop_list which will have list of scoopd object.

3. Create a method add_scoops in Bowl class which will add any no of Scoop objects given as parameter and store it in scoops_list.

4. Make getter and setter method for price property.

5. Make a method display to display flavour and price of each in and print total price of the bowl by adding all flavour scoops prices.

Ex.-

Output

Example 72

Explanation

• Defines two classes: Scoop for ice cream scoops and Bowl for holding multiple scoops.
• Scoop tracks the number of instances created with a class variable __counter, and has methods to set/get the price and a string representation.
• Bowl also tracks its instances with a class variable __counter, allows adding multiple Scoop instances, and displays the total price of all scoops.
• The sold static method in both classes returns the number of instances created, providing a way to track how many scoops and bowls have been sold.
• The expected output includes printed details of each scoop's flavor and price, along with the total price when Bowl.display() is called.

Example 73

Explanation

• Creates three Scoop objects for chocolate, berry, and vanilla flavors, each with a specific price set using the set_price method.
• Initializes a Bowl object and adds the scoops to it using the add_scoops method, which can accept both single and multiple scoop parameters.
• Calls the display method on the bowl object to show the contents of the bowl, likely including the flavors and their prices.
• Prints the total number of scoops sold and the total number of bowls sold by calling the sold class methods on Scoop and Bowl classes, respectively.

Output

###Q-7:Ice-Cream Bowl continue..

Making advancement in the above classes. Scoop and Bowl

1. Introduce a property max_scoops in Bowl class to signify maximum scoops that a bowl can have, exceeding that it will display Bowl is full. Take default value as 3.

2. no_of_scoop in Scoop class with default value of 1

3. Print <flavour> added with every scoop added.

Output:

Testing code-2 considering above test code executed

Output

Testing code-3, considering above tests executed

Output:

Example 74

Explanation

• Defines two classes, Scoop and Bowl, to model ice cream scoops and bowls that hold them.
• Scoop class has methods to set and get the price of a scoop, and a static method to count total scoops created.
• Bowl class can hold multiple scoops, with a method to add scoops and check if the bowl is full, and a method to display all scoops and their total price.
• Uses private attributes (e.g., __price, __scoop_list) to encapsulate data and prevent direct access from outside the class.
• Expected output includes messages when scoops are added or when the bowl is full, and displays the flavor and price of each scoop along with the total price when displayed.

Example 75

Explanation

• Creates instances of a Scoop class for different ice cream flavors (chocolate, berry, vanilla) and sets their prices.
• Uses the set_price method to assign a price to each scoop and prints the scoop details.
• Initializes a Bowl instance to hold scoops, using default parameters for maximum scoops.
• Adds the chocolate and berry scoops individually, and the vanilla scoop alongside the berry scoop in a single call.
• Calls the display method on the bowl to show the contents and details of the scoops added.

Output