Web Development Frameworks and Databases

Frameworks:
- Django: High-level, full-featured framework with ORM, authentication, and admin interface.
- Flask: Lightweight, flexible framework with minimal dependencies.
Templating Engines:
- Jinja2: Used by Flask, allows for templating and conditional logic.
- Template engine in Django: Allows for templating and conditional logic.
Databases:
- SQLite: Built-in database, easy to use and setup.
- MySQL, PostgreSQL: Popular databases for large-scale applications.
WSGI Servers:
- Gunicorn: Compatible with multiple frameworks, easy to use.
- uWSGI: High-performance, async-friendly server.

Lists:
- Ordered collection of items, can be modified.
- Supports indexing, slicing, and concatenation.
Tuples:
- Ordered, immutable collection of items.
- Faster and more memory-efficient than lists.
Dictionaries:
- Unordered collection of key-value pairs.
- Supports dynamic addition and removal of items.
Sets:
- Unordered collection of unique items.
- Supports union, intersection, and difference operations.

Classes:
- Define blueprint for objects, with attributes and methods.
- Supports inheritance, polymorphism, and encapsulation.
Inheritance:
- Child classes inherit attributes and methods from parent classes.
- Supports multiple inheritance.
Polymorphism:
- Methods can be overridden or overloaded.
- Supports operator overloading.
Encapsulation:
- Objects hide internal state and expose public methods.
- Supports data hiding and abstraction.

Frameworks:
- Django: A high-level framework that offers a comprehensive set of features, including an Object-Relational Mapping (ORM) system, built-in authentication mechanisms, and a user-friendly admin interface.
- Flask: A minimalist framework that prioritizes flexibility and simplicity, requiring few dependencies for basic web applications.
Templating Engines:
- Jinja2: This engine, utilized by Flask, supports advanced templating capabilities such as conditional logic and loops, making HTML rendering dynamic and efficient.
- Template Engine in Django: Similar to Jinja2, Django’s templating engine also enables dynamic content generation using template tags and filters.
Databases:
- SQLite: An embedded database that is straightforward to set up, making it ideal for development and smaller-scale applications.
- MySQL & PostgreSQL: Both are robust, widely-used relational database management systems suited for handling large-scale applications with greater complexity and data requirements.
WSGI Servers:
- Gunicorn: A Python WSGI server that is versatile and works well with several web frameworks, known for its ease of use.
- uWSGI: A high-performance server that supports asynchronous operations, designed to handle complex applications efficiently.

Lists:
- An ordered and mutable collection that allows for items to be changed, with capabilities like indexing, slicing, and concatenation for data manipulation.
Tuples:
- An ordered collection of items that is immutable, offering advantages in performance and memory usage compared to lists, making them suitable for fixed data structures.
Dictionaries:
- A collection of key-value pairs that is unordered, allowing for dynamic addition and removal of entries, facilitating flexible data storage and retrieval.
Sets:
- An unordered collection containing unique items which supports various mathematical operations, such as union, intersection, and difference, allowing for effective data comparison and manipulation.

Classes:
- Serve as blueprints for creating objects, encapsulating attributes and methods, which enables the reuse of code through object instances.
Inheritance:
- Allows child classes to inherit characteristics (attributes and methods) from parent classes, supporting single or multiple inheritance hierarchies.
Polymorphism:
- Provides the ability for methods to be redefined (overridden) or to function with different parameter types (overloaded), including supporting operator overloading for custom behavior.
Encapsulation:
- Refers to the principle where objects conceal their internal state while providing public methods for interaction, enhancing data security and abstraction in design.

A class serves as a blueprint for defining the properties and behaviors of objects.
An object is an instance of a class, possessing its individual attributes and methods.
Classes are defined using the class keyword in C++.
Objects are instantiated with the new keyword or by directly declaring a variable of the class type.

Inheritance allows one class to acquire the properties and behaviors of another.
The class being inherited from is known as the base class or parent class.
The class inheriting is referred to as the derived class or child class.
Inheritance is declared using the : syntax followed by public for public inheritance.
Types of inheritance include:
- Single inheritance: One derived class inherits from a single base class.
- Multiple inheritance: A derived class inherits from multiple base classes.
- Multilevel inheritance: A derived class inherits from a base class, which in turn inherits from another base class.
- Hierarchical inheritance: Multiple derived classes inherit from a single base class.
- Hybrid inheritance: A combination of multiple and multilevel inheritance.

Encapsulation encapsulates data and methods within a single unit, or class, hiding implementation details.
Access modifiers control accessibility to class members:
- public: Accessible from anywhere.
- private: Accessible only within the class itself.
- protected: Accessible within the class and any derived classes.
Getters and setters are methods used to access and modify private data members of a class.

Polymorphism enables objects to present multiple forms, facilitating interaction with different class objects as if they were from a common superclass.
Types of polymorphism include:
- Compile-time polymorphism (static): Resolved during compile time through function overloading and operator overloading.
- Run-time polymorphism (dynamic): Resolved at runtime through function overriding.
Function overriding occurs when a derived class implements a specific version of a function already defined in its base class.
Function overloading allows multiple functions to share the same name but differ in parameters.

Abstraction focuses on exposing only the necessary information while concealing implementation specifics, hence reducing complexity.
Abstract classes cannot be instantiated and serve as templates for other classes.
Abstract functions are declared without implementations, leaving it to derived classes to define behavior.
Interfaces consist of abstract classes that solely contain pure virtual functions (denoted by = 0).