Is it true that Python enforces strict information hiding like some other languages.?

Python does not have strict access modifiers (like `private` or `protected`). While conventions like prefixing with an underscore (`_`) suggest non-public attributes, they can still be accessed from outside the class, making direct attribute access a common, though discouraged, practice.

Python Classes and Inheritance Cheat Sheet

Object-Oriented Programming (OOP) in Python allows you to model real-world entities by creating classes that define data attributes (what an object is) and methods (how an object behaves), enabling code organization, abstraction, and reuse through inheritance.

Core Principles

Classes define a blueprint for objects, specifying their data attributes and methods.
Instances are specific objects created from a class, each with its own data attribute values.
Inheritance allows a child class to inherit attributes and methods from a parent class, promoting code reuse and establishing 'is-a' relationships.
Encapsulation, achieved through getters and setters, controls access to data attributes, enhancing code maintainability and preventing bugs.
Polymorphism allows objects of different classes to respond to the same method call in their own specific ways.

Action Steps

Define a class using the `class` keyword, specifying its name and parent class (if any).
Implement the `__init__` method to initialize instance attributes when an object is created.
Define methods within the class to specify object behavior, using `self` to refer to instance attributes.
Create instances of a class using `instance_name = ClassName(arguments)`.
Access instance attributes and methods using dot notation (e.g., `instance.attribute`, `instance.method()`).
For inheritance, define a subclass that inherits from a parent class by including the parent class name in parentheses during class definition.
In a subclass, add new methods or override parent class methods to customize behavior.
Use getters and setters (e.g., `get_age()`, `set_age(newage)`) to access and modify data attributes from outside the class for better encapsulation.

Key Terms

Class: A blueprint for creating objects, defining their attributes and methods.
Instance: A specific object created from a class, with its own unique set of data attribute values.
Attribute: A variable associated with a class (class attribute) or an instance (instance attribute), representing data.
Method: A function defined within a class that operates on instances of that class.
Inheritance: A mechanism where a new class (subclass) derives properties and behaviors from an existing class (superclass).
Superclass (Parent Class): The class from which another class inherits.
Subclass (Child Class): The class that inherits from another class.
Encapsulation: Bundling data (attributes) and methods that operate on the data within a single unit (class), often controlling access to the data.
Getter: A method used to retrieve the value of an attribute.
Setter: A method used to modify the value of an attribute.
__init__: A special method (constructor) called when an object is created, used for initializing instance attributes.
Dot Notation: Syntax used to access attributes and methods of an object (e.g., `object.attribute`, `object.method()`).

Pro Tips

Use `self` as the first parameter in instance methods to refer to the instance itself.
Employ getters and setters to manage access to data attributes, which is considered good style and prevents bugs.
When a subclass method has the same name as a superclass method, the subclass's method is called by default; use `ParentClassName.method_name(self, ...)` to explicitly call the parent's method.
Class variables, defined directly within the class but outside methods, are shared among all instances of that class.

Pitfalls to Avoid

Directly accessing or modifying data attributes from outside the class (e.g., `a.age = 'infinite'`) bypasses encapsulation, leading to potential errors and making code harder to maintain.
Forgetting to use `self` when defining or accessing instance attributes within methods can lead to `AttributeError`.
Calling a method on an instance of a parent class that only exists in a child class will result in an `AttributeError`.

Myth vs Reality

Python enforces strict information hiding like some other languages.: Python does not have strict access modifiers (like `private` or `protected`). While conventions like prefixing with an underscore (`_`) suggest non-public attributes, they can still be accessed from outside the class, making direct attribute access a common, though discouraged, practice.

Real World Examples

Modeling animals with different characteristics and behaviors.: A base `Animal` class can define common attributes like `age` and `name`, and methods like `get_age()`. Subclasses like `Cat` and `Rabbit` can inherit from `Animal`, adding specific behaviors like `speak()` ('meow') or unique attributes like `tag` for rabbits.
Creating a hierarchy of people with varying roles.: A `Person` class can have `name` and `age`. A `Student` subclass can inherit from `Person` and add a `major` attribute and a `change_major()` method, demonstrating how subclasses extend parent functionality.

Timeline

Last Time: Introduced abstract data types through classes, using Coordinate and Fraction examples.
Today: Covered more on classes, including getters, setters, information hiding, class variables, and inheritance.