Object-Oriented vs Procedural Programming in Python

A programming paradigm where programs are divided into functions, and data is primarily stored in global variables. Functions have local data, and can call each other.

A programming paradigm that uses objects to encapsulate data and operations within a single unit. Objects can have their own internal data and functions (methods) to operate on that data. Access to data is typically limited to the object itself.

Data that is available to all parts of a program, even outside of functions.

Data specific to a particular function or object that is not accessible outside of that function or object.

Functions within an object used to interact with the object's data. They define the allowed operations on the enclosed data.

The concept that in OOP, most data should be stored within objects and not globally accessible. This helps prevent unintended data modification or conflicts.

The primary focus of OOP is how data is structured and the operations that can be performed on that structured data.

A conditional statement often used in Python programs to determine if a script is being run directly or imported as a module. Only executes the code within the if block when the script is run directly (not imported).

A sequence of characters that represents text, often enclosed within quotation marks.

A programming paradigm that focuses on the sequential execution of procedures (functions) to achieve a specific goal.

A special method that determines how an object is represented as a string.

A technique in OOP that allows a single function or method to have multiple definitions based on the types of arguments passed to it.

A special method in OOP that defines the string representation of an object when it is used in a print statement.

A special method that provides a user-friendly string representation of an object when it is printed or used in a string context.

The ability for a new class to inherit properties and behaviors from an existing class, promoting code reuse and reducing redundancy.

The ability to define custom operations for user-defined classes, allowing them to behave like built-in datatypes. For example, you can add two objects of your own custom class using the '+' operator.

The ability to define equality comparison (==) and ordering comparison (<, > etc.) for custom classes. This enables sorting and other operations that rely on comparing objects.

A mechanism in programming to handle runtime errors. Exceptions allow your code to catch and respond to unexpected situations, preventing the program from crashing immediately.

Handling exceptions effectively allows your program to gracefully deal with unexpected situations. You can catch specific types of errors, perform custom actions, and continue execution without crashing.

A section of code designed to handle and respond to specific exceptions that might occur in the surrounding try block. If an exception of the matching type is thrown, this block is executed.

This code block always executes after a try-except block, regardless of whether an exception was thrown or not. It's commonly used for cleanup operations.

Allows you to define how your objects are accessed using operators like square brackets ([]). This lets you treat objects as if they were lists or arrays, enabling you to get or set specific elements within them.

A class that represents a geometric polygon. Polygon objects could store information about their vertices and potentially have methods to manipulate or calculate their properties.

Calling the constructor of the parent class to initialize inherited properties.

A Python class that represents a triangle, inheriting from MyPolygon and adding specific methods.

Creating a new object of a class.

A Python class representing a single vertex (point) used to build more complex polygons.

A Python class representing a regular pentagon, inheriting from MyPolygon and using a vertex to create its shape.

The process of adding extra functionality to a class, such as calculating area or performing rotations.

A method that allows access to an object's elements using square brackets, like object[key], making the object behave similarly to a list or dictionary.

In Python, this refers to the ability to use a special method named __len__ within a custom class to define how the built-in len function works on instances of that class.

A group of mathematical transformations, specifically rotations around a specific point (in this case, the origin), that form a special type of mathematical structure called a Lie group.

A mathematical function that essentially 'rotates' a point (x, y) around the origin by a given angle θ.

The transformation that results in no change, analogous to multiplying by 1 in standard arithmetic.

For every rotation, there's a corresponding rotation that 'undoes' it, getting you back to the original position.

The ability to create new classes that inherit properties and methods from existing parent classes, allowing for specialization and code reuse.

In the Object-Oriented Programming (OOP) paradigm, a program is divided into objects. Each object bundles data specific to it and offers operations to interact with that data. Objects can use data from other objects.

In OOP, the focus shifts from global data to organizing and managing data within objects. Data is treated as a central structure with specific operations defined for it.

A class is a blueprint for creating objects. It defines the structure and functionality of objects of that type. For example, a 'Car' class might define properties like 'color', 'model', and methods like 'start' or 'accelerate'.

An instance of a class is a specific object created from that class. Each object is an independent entity with its own unique data. For example, you can create an instance of the 'Car' class named 'myCar' and set its color to 'red' and then create another instance named 'yourCar' with a different color.

A constructor, typically named 'init' in Python, is a special method that initializes the state of an object when it is created. It assigns initial values to the object's attributes. For example, a 'Car' constructor might set the default color to 'white' when a new 'Car' object is created.

A member variable is a variable that belongs to a specific instance of a class. It holds information about the object's state. For example, a 'Car' instance might have a member variable named 'color' that stores the color of the car.

A member function (or method) is a function that belongs to a class and operates on an instance of that class. It defines an action that can be performed on the object. For example, a 'Car' class might have a member function named 'start' that changes the car's state to 'started' when called.

Private variables and functions in OOP are hidden from the outside world. They are accessible only within the class, and they are not directly visible to other objects or parts of the program. This helps to encapsulate data and logic within the class and prevent outside interference.

In Python, a variable or function is marked as private by adding two underscores ('__') before its name. This signals that it is not intended to be accessed directly from outside the class. For example, a variable named '__secret' would be considered private.

In Python, private members are not truly hidden, but they can help enforce encapsulation and are generally treated as private. Think of them as gentle reminders that you should avoid directly accessing them from outside the class.