DEV Community: Anirban Das

Django Fundamentals: Security and ORM Techniques

Anirban Das — Tue, 04 Apr 2023 07:46:37 +0000

1. Settings file

In Django, the settings file is an essential component of the project configuration. It contains various settings that determine how the project will behave, such as database connections, time zones, and static files management, among others.

What is secret key?

The secret key is one of the settings found in the Django settings file (settings.py). It is a unique, randomly generated string that is used for cryptographic purposes, such as signing cookies, generating secure tokens, and other security-related tasks. The secret key helps protect sensitive information and keeps the web application secure.

It is crucial to keep the secret key secret, as exposing it could lead to various security vulnerabilities. In production, it is a good practice to store the secret key as an environment variable or in a secure secret management system, rather than directly in the settings.py file, to avoid accidentally leaking it in version control systems like Git.

What are the default Django apps inside it? Are there more?

Django comes with several built-in apps that provide common functionality needed in web applications. When you create a new Django project, some of these apps are included in the default project settings under the INSTALLED_APPS list in the settings.py file. The default Django apps include:

django.contrib.admin: Provides the Django admin site, an automatically-generated interface for managing the data in your application.
django.contrib.auth: Provides authentication and authorization features such as user registration, login, and permissions management.
django.contrib.contenttypes: Allows you to create generic relations between models, enabling you to link any two models in a more flexible way.
django.contrib.sessions: Manages sessions for your application, allowing you to store data that is specific to a particular user across multiple requests.
django.contrib.messages: Enables you to show temporary, one-time notification messages to users after they perform certain actions, like form submissions.
django.contrib.staticfiles: Handles the management and serving of static files, such as CSS, JavaScript, and images.

These are the default apps provided by Django, but there are many more built-in apps available that you can add to your project depending on your needs. Some additional Django apps include:

django.contrib.sites: Allows you to manage multiple websites with a single Django project.
django.contrib.humanize: Provides a set of template filters that makes it easier to format numbers, dates, and other data in a more human-readable way.
django.contrib.postgres: Provides PostgreSQL-specific features like ArrayField, HStoreField, and other specialized database fields.
django.contrib.gis: Offers Geographic Information System (GIS) support for Django, including spatial fields and spatial querying capabilities.

To use any of these additional apps, you need to add them to the INSTALLED_APPS list in your settings.py file and configure them as needed.

What is middleware?

Middleware is a way to process requests and responses globally in a Django application. Middleware components are classes that are executed at various stages during the request/response processing flow. They allow you to perform operations on the incoming request before it reaches the view or on the outgoing response before it's sent back to the client.

What are different kinds of middleware?

There are three types of middleware:

View middleware: View middleware is the lowest-level middleware. It is executed before the view is called and after the view is called, but before the response is returned to the client. View middleware is useful for tasks that need to be performed on every request, such as logging, authentication, or request throttling.
Template response middleware: Template response middleware is executed after the view is called and before the response is returned to the client. It is useful for tasks that need to be performed on every response, such as adding a header to every response.
Exception middleware: Exception middleware is executed when an exception occurs in the view. It is useful for tasks that need to be performed when an exception occurs, such as logging the exception or sending an email to the site administrator.

CSRF

Cross-site request forgery (CSRF) is a type of attack that forces an end user to execute unwanted actions on a web application in which they're currently authenticated. CSRF attacks specifically target state-changing requests, not theft of data, since the attacker has no way to see the response to the forged request.

XSS

Cross-site scripting (XSS) is a type of attack that involves injecting malicious scripts into a web application. XSS attacks occur when an attacker uses a web application to send malicious code, generally in the form of a browser side script, to a different end user. The end user's browser has no way to know that the script should not be trusted, and will execute the script. Because it thinks the script came from a trusted source, the malicious script can access any cookies, session tokens, or other sensitive information retained by the browser and used with that site. These scripts can even rewrite the content of the HTML page.

Click Jacking

Clickjacking is a type of attack that tricks a user into clicking on something different than what they perceive they are clicking on. This is done by overlaying transparent or opaque layers on top of the desired website, tricking the user into clicking on the transparent or opaque layer instead of the website itself.

Any other middleware that is there?

There are several other built-in middleware classes that you can use in your Django project. Here's a brief overview of some key middleware:

django.middleware.security.SecurityMiddleware: This middleware adds several security-related headers to every response, such as the X-Frame-Options header, which prevents clickjacking attacks.
django.middleware.clickjacking.XFrameOptionsMiddleware: This middleware adds the X-Frame-Options header to every response, which prevents clickjacking attacks.
django.middleware.csrf.CsrfViewMiddleware: This middleware adds a CSRF token to every POST request, which prevents cross-site request forgery attacks.
django.middleware.common.CommonMiddleware: This middleware adds several security-related headers to every response, such as the X-Content-Type-Options header, which prevents MIME type sniffing attacks.
django.middleware.clickjacking.XFrameOptionsMiddleware: This middleware adds the X-Frame-Options header to every response, which prevents clickjacking attacks.
django.middleware.csrf.CsrfViewMiddleware: This middleware adds a CSRF token to every POST request, which prevents cross-site request forgery attacks.
django.middleware.common.CommonMiddleware: This middleware adds several security-related headers to every response, such as the X-Content-Type-Options header, which prevents MIME type sniffing attacks.

What is (WSGI) ?

WSGI, or Web Server Gateway Interface, is a standard interface between web servers and Python web applications or frameworks. It allows for greater compatibility and interchangeability between different web servers and Python applications. WSGI was introduced as part of the PEP 333 (Python Enhancement Proposal) to create a common interface that would enable web servers to communicate with various Python web applications, regardless of the underlying framework or technology.

WSGI acts as a middleware that translates requests coming from a web server into a format that Python web applications can understand, and vice versa. By conforming to the WSGI standard, web applications can be deployed on any WSGI-compliant web server, and web servers can host any WSGI-compliant application.

2. Models file

In Django, models are Python classes that inherit from django.db.models.Model. They define the fields and behavior of the data that you want to store. Each attribute in the model class represents a field in the database table. The fields are instances of Django field classes such as CharField, IntegerField, DateField, ForeignKey, etc.

What is ondelete Cascade?

on_delete is a parameter used in Django models when defining ForeignKey or OneToOneField relationships. It specifies what should happen when the referenced object (the target of the ForeignKey or OneToOneField) is deleted.

CASCADE is one of the options you can use for the on_delete parameter. When the on_delete is set to CASCADE, it means that when the referenced object is deleted, all related objects (those that have a ForeignKey or OneToOneField pointing to the deleted object) will also be deleted. This is useful when you want to maintain referential integrity in your database and ensure that there are no orphaned records.

Field and Validators

Django provides various field classes that you can use to define the structure and data types of your model's attributes. These fields automatically include validation, form widgets, and database column types suitable for the data they are intended to store. Some common field types include:

CharField: A character field for storing short strings.
TextField: A large text field for storing longer strings.
IntegerField: An integer field for storing integer values.
FloatField: A floating-point field for storing decimal values.
DateField: A field for storing date values (year, month, day).
DateTimeField: A field for storing date and time values.
BooleanField: A field for storing boolean values (True or False).
ForeignKey: A field for creating a one-to-many relationship between two models.
OneToOneField: A field for creating a one-to-one relationship between two models.
ManyToManyField: A field for creating a many-to-many relationship between two models.

Django also provides built-in validators that can be added to fields to enforce specific constraints on the data. Validators are functions that take a value as input and raise a ValidationError if the value does not meet the specified criteria. Some common validators include:

MinValueValidator: Validates that the value is greater than or equal to a minimum value.
MaxValueValidator: Validates that the value is less than or equal to a maximum value.
MinLengthValidator: Validates that the value has a minimum length.
MaxLengthValidator: Validates that the value has a maximum length.
EmailValidator: Validates that the value is a valid email address.
URLValidator: Validates that the value is a valid URL.
RegexValidator: Validates that the value matches a specified regular expression.

Python module vs. Python class

A Python module is a file containing Python code, typically with a .py extension. The module can include functions, classes, and variables, as well as executable code. Modules are used to organize your code and make it more reusable and maintainable. You can import functions or classes from a module into another module, script, or the Python interpreter.

A Python class, on the other hand, is a code template for creating objects. It defines the structure, attributes, and methods that instances of the class will have. Classes are used in object-oriented programming to encapsulate related data and behavior and promote code reuse and modularity. Instances of a class are individual objects that have their own set of attributes and can use the methods defined in the class.

In summary, a module is a file containing Python code (which can include classes), while a class is a template for creating objects with a specific structure and behavior.

3. Django ORM

Django ORM (Object-Relational Mapping) is a powerful and high-level abstraction over the database that allows you to interact with the database using Python objects and methods instead of writing raw SQL queries. The ORM translates the Python code you write into SQL queries, which are then executed on the database. This approach makes it easier to write, read, and maintain database-related code and allows you to switch between different databases with minimal code changes.

Using ORM queries in Django Shell

The Django shell is an interactive Python shell that has your Django project's environment and settings pre-loaded. You can use the Django shell to interact with your models, execute ORM queries, and inspect the results. To start the Django shell, run the following command in your terminal:

python manage.py shell

Inside the shell, you can import your models and perform ORM queries like creating, retrieving, updating, or deleting records. For example:

from myapp.models import MyModel

# Create a new record
my_instance = MyModel(name="Example", value=42)
my_instance.save()

# Retrieve records
all_instances = MyModel.objects.all()

# Update a record
my_instance.value = 50
my_instance.save()

# Delete a record
my_instance.delete()

Turning ORM to SQL in Django Shell

Django ORM queries can be translated into raw SQL by using the query attribute of a queryset. For example:

from myapp.models import MyModel

queryset = MyModel.objects.filter(name="Example")
sql_query = str(queryset.query)
print(sql_query)

What are Aggregations?

Aggregations in Django ORM are operations that perform calculations on a set of records and return a single value, such as counting the number of records, calculating the average, sum, minimum, or maximum of a field. Aggregations can be used to perform complex calculations on the data stored in your models without having to retrieve all records and process them in Python. You can use the aggregate() function along with aggregation classes like Count, Avg, Sum, Min, and Max from django.db.models. For example:

from django.db.models import Count, Avg
from myapp.models import MyModel

# Count the number of records
record_count = MyModel.objects.aggregate(Count('id'))

# Calculate the average value of the 'value' field
average_value = MyModel.objects.aggregate(Avg('value'))

What are Annotations?

Annotations in Django ORM are a way to add extra fields to each record in a queryset by performing calculations based on the values of other fields or aggregating data from related models. Annotations can be used for tasks like calculating the total price of items in an order or adding a field with a boolean value that indicates if a certain condition is met. You can use the annotate() function along with expressions like F, ExpressionWrapper, and aggregation classes. For example:

from django.db.models import F, ExpressionWrapper, BooleanField
from myapp.models import MyModel

# Annotate each record with a 'is_value_greater_than_10' field
annotated_queryset = MyModel.objects.annotate(
    is_value_greater_than_10=ExpressionWrapper(F('value') > 10, output_field=BooleanField())
)

What is a migration file? Why is it needed?

A migration file is a file that contains the instructions for making changes to the database schema. It is generated automatically by Django when you make changes to your models. You can use the makemigrations command to generate a migration file for your models. For example:

python manage.py makemigrations

The migration file contains the instructions for creating, modifying, or deleting the database tables and columns that correspond to your models. You can use the migrate command to apply the changes to the database. For example:

python manage.py migrate

Migration files are needed for several reasons:

Version Control: They help to maintain a version control system for the database schema, allowing developers to easily manage and track changes to the schema over time.
Collaboration: Migration files make it easier for teams of developers to collaborate on a project, since each developer can create their own migration file for the changes they made, avoiding conflicts and keeping everyone on the same page.
Deployment: When deploying an application to a new environment, migration files ensure that the database schema can be created or updated in a consistent and controlled manner.

What are SQL transactions? (non ORM concept)

SQL transactions are a way to execute a series of operations on a database as a single unit of work. Transactions follow the ACID properties: Atomicity, Consistency, Isolation, and Durability. These properties ensure that the database remains in a consistent state even when multiple users are accessing it simultaneously, or when unexpected errors occur.

Atomicity: A transaction is atomic, meaning that either all of its operations are executed successfully, or none of them are. If any operation fails, the entire transaction is rolled back, and the database returns to its state before the transaction started.
Consistency: A transaction ensures that the database moves from one consistent state to another. Once a transaction is committed, all changes made during that transaction are permanent and the database is in a consistent state.
Isolation: Transactions are isolated from each other, which means that the operations of one transaction are not visible to other transactions until the transaction has been committed.
Durability: Once a transaction is committed, its changes to the database are permanent, even in the case of system failures.

What are atomic transactions?

Atomic transactions, as the name suggests, are a subset of SQL transactions that specifically emphasize the atomicity property. The term "atomic" refers to the all-or-nothing nature of these transactions. In an atomic transaction, if any operation within the transaction fails, the entire transaction is rolled back, and the database remains unchanged. This ensures that the database is never left in an inconsistent state, providing a higher level of reliability and data integrity.

REFERENCES

HTML AND CSS CONCEPTS

Anirban Das — Thu, 02 Mar 2023 08:05:48 +0000

BOX MODEL

CSS Box Model represents each HTML elements as a rectangular box
Every box is composed of four parts:
- Content: This is the actual content of the element, such as text, an image, or a video player.
- Padding: This is the space from the content area to the border area.
- Border: This is the area that surrounds the padding area.
- Margin: This is the outer space from the border area. It is used to separate the element from its neighbouring elements.
Some of the properties of CSS Box Model includes width, height, padding, border and margin.
- Width: This is used to set the width of the content area.
- Height: This is used to set the height of the content area.
- Padding: This are the padding properties which includes padding-top, padding-right, padding-left and padding-bottom. We can also use padding property to combine all the padding properties in clockwise direction.
- Border: This are the border properties which include border-width, border-height, border-style and border-color. Border can also be set on each sides (top, right, bottom, left) separately.
- Margin: This are the margin properties which includes margin-top, margin-right, margin-bottom, margin-left. We can also use margin property to combine all the margin properties in clockwise direction.
We can combine all the properties above to implement the CSS Box Model.

Example:

.card {
  width: 22rem;
  height: 22rem;
  padding: 2rem;
  border: 0.125rem dotted red;
  margin: 2rem;
}

INLINE VS BLOCK ELEMENTS

1. INLINE ELEMENTS

Inline elements does not start on a new line and it only takes up width as much as the content provided.
Some of the inline elements in HTML are: <a>, <br>, <button>, <img>, <span>, <strong>, <span> and <input>.
Inline elements can only be positioned using CSS by the amount of content they have inside them.
Inline elements cannot have margin or padding applied to them, they can only have borders around them.

2. BLOCK ELEMENTS

Block elements takes the full width of their container and always starts on a new line.
The browsers automatically adds some extra space (margin) before and after the element.
Some of the block elements in HTML are: <div>, <p>, <header>, <footer>, <section>, <form>, <nav> and <main>.
Block elements can be positioned using CSS
Block elements also have margin, padding and border applied on them.

POSITIONING: RELATIVE/ABSOLUTE

1. RELATIVE POSITIONING

Elements which have position: relative; is always positioned relative to its normal position.
Elemnts with relative position takes up space in the HTML page.
Setting the properties like top, right, bottom and left will make the relatively positioned element adjusted away from its normal position.
Also the other content will not be adjusted to fit into any gap left by the element.

2. ABSOLUTE POSITIONING

Elements which have position: absolute is positioned relative to the nearest positioned parent element.
If an absolute positioned element have no positioned parent element than it will use the document body and will move along with the page scrolling.
Absolute positioned elements will get remove from the normal flow of the page and can overlap elements.
Properties that can be used to position to the relative parent element are top, right, bottom and left.

COMMON CSS STRUCTURAL CLASSES

There are several common CSS structural classes used to style and layout HTML elements. Some of them are:
:first-child: They represents the element that are prior to their siblings in a tree structure.

.card li:first-child {
  color: gray;
}

:nth-child(n): They apply CSS properties to those elements that appear at the position evaluated by the resultant of an expression.

.card li:nth-child(2n+1) {
  color: gray;
}

:last-child: They are psuedo class that represents the element that is at the end of its siblings in a tree structure.

.card li:last-child {
  color: gray;
}

:nth-last-child(n): This is same as :nth-child(n) but the positioning of elements start from the end.

.card li:nth-last-child(2n+1) {
  color: gray;
}

:only-child: They represents the element that is a sole child of the parent element and there is no other siblings.

div p:only-child {
  color: gray;
}

:first-of-type: They represent the first element of the one type of siblings.

.card li:first-of-type {
  color: gray;
}

:nth-of-type(n): They represents those elements of the same type at the position given as n.

.card li:nth-of-type(2n) {
  color: gray;
}

COMMON CSS STYLING CLASSES

1. COLORS

.text-muted: Applies a light gray color to text for muted or secondary content.
.text-primary: Applies a primary color to text for main focus or importance.
.text-success: Applies a green color to text for success or positive outcome.
.text-warning: Applies an orange or yellow color to text for warning or caution.
.text-danger: Applies a red color to text for danger or critical issues.

2. SPACING

.p-1, .p-2, .p-3: Adds padding to an element in various sizes.
.m-1, .m-2, .m-3: Adds margin to an element in various sizes.
.mt-1, .mt-2, .mt-3: Adds margin-top to an element in various sizes.
.mb-1, .mb-2, .mb-3: Adds margin-bottom to an element in various sizes.
.ml-1, .ml-2, .ml-3: Adds margin-left to an element in various sizes.
.mr-1, .mr-2, .mr-3: Adds margin-right to an element in various sizes.

3. OTHERS

.rounded: Applies rounded corners to an element.
.shadow: Applies a shadow effect to an element.
.opacity-50: Applies 50% opacity to an element, making it semi-transparent.
.text-center: Centers text within an element.
.text-left: Aligns text to the left within an element.
.text-right: Aligns text to the right within an element.

CSS SPECIFICITY

CSS specificity is a measure of how specific a selector is in targeting a particular HTML element.
Here's a breakdown of how specificity is calculated:
- Element selectors have the lowest specificity and are worth 1 point.
- Class selectors are worth 10 points.
- ID selectors are worth 100 points.
- Inline styles have the highest specificity and are worth 1000 points.
When multiple styles are applied to an element, the style with the highest specificity values takes precedence.
If two selectors have the same specificity value, the one defined last in the CSS document will take precedence.

CSS RESPONSIVE QUERIES

It is used in CSS to apply styles to different devices or screen sizes.
Media queries allow web developers to specify different CSS styles for different devices, resolutions, and orientations.
They are written using the @media rule.
We can use queries to target specific device sizes, such as smartphones or tablets.
- @media screen and (max-width: 767px): This is commonly used for smartphone devices.
- @media screen and (min-width: 768px) and (max-width: 1023px): They are commonly used for tablet devices
- @media screen and (min-width: 1024px): This is commonly used for large devices like PC, Laptop.

FLEXBOX/GRID

1. FLEXBOX

One-dimensional layout system.
Aligns elements along a single axis (horizontally or vertically)
Allows control over size, order, and alignment of elements within a container.
- display: flex; - Defines a flex container.
- flex-direction - Defines the main axis of the flex container, either row or column.
- justify-content - Aligns items along the main axis.
- align-items - Aligns items along the cross axis.
- flex-wrap - Determines if items should wrap or stay on a single line.
- flex-grow - apecifies how much an item can grow in relation to the other items.

2. GRID

Two-dimensional layout system.
Creates a grid of rows and columns.
Allows placement of elements within the grid.
Provides more control over layout, making it suitable for complex, multi-dimensional layouts that adapt to different screen sizes.
- display: grid; - Defines a grid container.
- grid-template-columns/grid-template-rows - Defines the number and size of columns/rows in the grid.
- grid-column/grid-row - Specifies which columns/rows an element should span.
- grid-gap - Defines the gap between grid cells.
- justify-items - Aligns items along the horizontal axis.
- align-items - Aligns items along the vertical axis.

COMMON HEADER META TAGS

Header meta tags are an important part of a web page's HTML code that provide information about the page's content to search engines, social media platforms, and other web services.
To Specify the character encoding used by the page. UTF-8 is the most widely used character encoding and supports all Unicode characters.

<meta charset="UTF-8">

To Specify the viewport settings for mobile devices, which affects the layout and scaling of the page on different devices.

<meta name="viewport" content="width=device-width, initial-scale=1.0">

To Specify the title of the page, which appears in the browser's title bar and is used by search engines as the title of the search result.

<title>Page Title</title>

To Specify a brief description of the page's content, which appears in search results and is used by search engines to understand the page's content.

<meta name="description" content="Page description">

To Specify a comma-separated list of keywords that describe the page's content, which can help search engines understand the page's topic and improve its ranking.

<meta name="keywords" content="keyword1, keyword2, keyword3">

To Specify whether search engines should index the page and follow its links.

<meta name="robots" content="index, follow">

To Specify the canonical URL of the page, which is the preferred URL that search engines should use to index the page.

<link rel="canonical" href="https://www.example.com/">

CSS LENGTH UNITS

ABSOLUTE UNITS

em: Based on the font size of the parent element.
rem: Based on the font size of the root element.
%: Based on the size of the parent element.
vw/vh: Based on the viewport width and height.

RELATIVE UNITS

px: Based on the physical pixel of the screen.
in/cm/mm: Based on physical measurements.

CONCLUSION

HTML and CSS are fundamental tools for web developers.
HTML provides the structure and content of a web page.
CSS handles the presentation and styling of that content.
HTML and CSS are constantly evolving with new updates being released regularly.
HTML and CSS are integral to modern web development and will continue to be so in the future.
Overall, HTML and CSS are crucial tools for web development that every aspiring web developer should learn.

REFERENCES

Revision - 27/02/2023

Anirban Das — Mon, 27 Feb 2023 07:04:06 +0000

1. Why is it recommended to use semantic elements when we can just make an entire website comprising div elements?

Answer:

They are more descriptive than divs.
Easy for developers to read and understand.
Screen readers and browsers can interpret Semantic HTML better, which makes it more accessible.
Also helps in page ranking for search engine(SEO)

2. What is the difference between WHERE and HAVING processes in SQL?

Answer:

The WHERE clause is used to filter rows based on a specified condition, while the HAVING clause is used to filter groups based on a specified condition.
The HAVING clause can only be used in conjunction with the GROUP BY clause.

3. What are void elements in HTML?

Answer:

HTML elements whose content model never allows it to have contents under any circumstance.
They do not have closing tags or do not need to be closed.
They cannot have any Child Nodes(i.e., nested elements or text nodes).
For Example <br />, <img />, <hr />, etc.

4. Why do we use dunder methods in python?

Answer:
A dunder method is a method in Python that has a double underscore prefix and suffix in its name, such as init or str. These methods are also known as "magic methods" or "special methods" because they define special behavior for built-in Python operations.

For example, the _init_ method is called when an object is created and allows you to define how the object should be initialized. The _str_ method is called when an object is converted to a string and allows you to define how the object should be represented as a string.

5. What is the difference between padding and margin in HTML?

Answer:
The margin of an element represents the outside space of the element itself, while the padding represents the inner space surrounding the element.

6. What is the difference between git and GitHub?

Answer:

Git	GitHub
Git is a version control system to manage source code history	GitHub is a hosting service for Git repositories
Git is installed locally on the system	GitHub is hosted on the web
Git is a command-line tool	GitHub is a graphical user interface
Git has no user management feature	GitHub has a built-in user management feature

7. What are the different methods used for accessing the values of a dictionary?

Answer:

Using keys to access values: We can access the value of a dictionary by specifying its key in square brackets.
Using the values() method: We can use the values() method to return a list of all the values in a dictionary.
Using the items() method: We can use the items() method to return a list of key-value pairs in the form of tuples.
Using a loop to iterate through keys or values: We can use a loop to iterate through the keys or values of a dictionary.
Using the get() method: We can use the get() method to retrieve the value associated with a key in a dictionary.

8. How do we stage all files except a specific file without using "gitignore"?

Answer:

First step is to add all the files to the staging area using

git add .

Then remove the specific file from the staging area using git reset

git reset -- filename

9. Difference between class and id in HTML and CSS.

Answer:

Both are attributes of HTML elements and can be used as a selector in css, but the main difference lies that

A Class name can be used any number of times with different elements
Whereas ID name is specific and can be used only once within a HTML page

10. How to revert a specific commit pushed to git due to human error?

Answer:
To revert a commit in Git, use the command:

git revert <commit>

Replace <commit> with the commit hash which can be found from:

git log

command by copying previous commit hash.

11. While applying different selectors in HTML and CSS, what is the order of Specificity?

Answer:

Inline styles (Highest Specificity)
ID
Classes, pseudo-classes
Elements and pseudo-elements (Lowest Specificity)

12. In what scenarios is grid better than flex and vice-versa?

Answer:

We use grid when the design needs items in the grid to line up in columns and rows
We use flex when we want items to get stack up independently on others in terms of length and alignment

13. What is the difference between SQL and NoSQL database?

Answer:

SQL	NoSQL
It is a Relation Database Management System	It is a Non-Relational Database Management System
Stores data in the form of tables with rows and columns	Stores data in various format including document-oriented, key-value, graph-based models
SQL databases have a fixed schema, which means that the data structure must be defined before data is stored	NoSQL databases have a dynamic schema, which allows for more flexibility in storing and manipulating data
They can handle limited amounts of data	They can handle large amounts of data

14. Do we have "closures" in python?

Answer:

Yes, Python has closures. In Python, a closure is a function object that has access to variables in its enclosing lexical scope, even when the function is called outside that scope. This allows for data to be encapsulated and protected from being modified outside the closure.

15. What are the differences between the operators '=','==' and, 'is' keyword in python?

Answer:

The '=' operator is used for variable assignment
The '==' operator is used for comparing values for equality. It checks only its values and not its type
Whereas 'is' keyword is used to compare objects/variables on its value and also on its type

16. What are meta tags and why do we use them in HTML?

Answer:

Meta tags are HTML tags that provide metadata about a web page. They are placed in the head section of an HTML document and are not visible to the user
Meta tags are used because they provide information that can help improve the visibility and ranking of a web page in search results.
They also provide information about the web page to users such as screenreaders.

Essential SQL Concepts

Anirban Das — Tue, 21 Feb 2023 10:32:58 +0000

Introduction

Databases are critical components in today's software systems, they are an organized collection of data. Most companies now a days use databases to store, manage and retrieve information. In this paper, we will explore some of the key concepts that are important to understand when working with databases. These concepts include:
1) ACID
2) CAP Theorem
3) Joins
4) Aggregations, Filters in queries
5) Normalizations
6) Indexes
7) Transactions
8) Locking mechanism
9) Database Isolation Levels
10) Triggers

ACID

To maintain the integrity of the data. there are four properties described in DBMS, which are known as the ACID properties. ACID is an acronym that stands for Atomicity, Consistency, Isolation and Durability.
The ACID properties are meant for the transaction that goes through a different group of tasks. The four properties of ACID are described below:

Atomicity

The term atomicity defines that the data remains atomic. It means if any operation is performed on the data, either it should be performed or executed completely or should not be executed at all. That means the operation should not break in between or execute partially.

Example : There are two accounts A and B in a bank and account A wishes to send $10 to B, were B already has $100 in his account. So after the transaction account B should have $110 and account A have $20 left. Successful transaction like debit and credit operations are done simultaneously will lead to atomicity.

Consistency

The word Consistency means that the value should remain preserved always. Which means if a change in the database is made, it should remain preserved always. In the case of transactions, the integrity of the data is very essential so that the database remains consistent before and after the transaction.

Example : There are three accounts, A, B, and C. A debits $50 to B, reducing B's balance to $150. A then debits $20 to C, with C's balance correctly read as $250. Inconsistency occurs if B and C's balance reads $300 after the first transaction, indicating an unsuccessful debit.

Isolation

The term Isolation means separation. Isolation is the property of a database where no data should affect the other one and may occur concurrently. In short, the operation on one database should begin when the operation on the first database gets complete, which means if two operation are being performed on two different databases, they may not affect the value of one another.

Example : If two operations are running on two different accounts, then the value of both accounts should not get affected. As seen in the diagram below, account A is making T1 and T2 transactions to account B and C, but both are executing independently without affecting each other, it is known as Isolation.

Durability

The term Durability ensures that the data after the successful execution of the operation becomes permanent in the database. The durability of the data should be so perfect that even if the systems fails or leads to a crash, the database still survives.

Therefore, The ACID property of Database plays an important role in maintaining the consistency and availability of data in the database.

CAP Theorem

The CAP theorem is a rule that explains the difficult choices we must make when creating a distributed computer system. The rule says that it's impossible for such a system to offer all three of these things at the same time:

ensuring that all nodes in the system see the same data (consistency),
providing high availability, which means that the system keeps running even when some parts of it fail, and
allowing every request to be completed without delay (partition tolerance) even when there is a network failure. So, when designing a distributed system, you need to prioritize which of these is most important and make trade-offs to achieve your desired system behavior.

Consistency means that all nodes in the systems see the same data at the same time, no matter which node they connect to. For this to happen, whenever data is written to one node, it must be instantly forwarded or replicated to all the other nodes in the system before the write is deemed ‘successful.’

Availability means that every request receives a response, without guarantee that it contains the most recent version of the data.

Partition tolerance means that the system continues to operate even when network partitions occur. In practice, designers of distributed systems must choose to sacrifice one of these properties to ensure that the other two are met.

Joins

Joins are used to combine data from two or more tables in a database based on the related columns between them. There are several types of joins, including inner join, left join, right join and full outer join.

Inner Join

Inner join or just join return only the rows that have matching values in both tables.

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;

This query will select only the records that matches both the Orders and the Customers table.

Left Join

Left join or Left outer join returns all the rows from the left table and the matching rows from the right table.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;

This query will return all the rows from the customers table even if it didn't matches with the orders table.

Right Join

Right join or Right outer join returns all the rows from the right table and the matching rows from the left table.

SELECT Orders.OrderID, Employees.LastName, Employees.FirstName
FROM Orders
RIGHT JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID
ORDER BY Orders.OrderID;

This query will return all the rows from the right table(employees) and only the matching columns of the left table(orders)

Full Outer Join

Full outer join or Full join returns all the rows from both tables, including any non-matching rows.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

This query will return all the rows from both the tables which are joined using full join

Aggregations, Filters in queries

An Aggregate function in SQL perform a calculation on multiple values and returns a single value, in other words it returns one value after calculating multiple values of a column. We often use aggregate functions with the GROUP BY and HAVING clauses of the SELECT statement when we select more columns with the aggregate.

Various types of SQL aggregate functions are:

Count()
Sum()
Avg()
Min()
Max()

COUNT() Function

The COUNT() function returns the number of rows in a database table

SELECT COUNT(ball)
FROM deliveries;

This query will return the total number of balls or rows are there in ball column from deliveries table

SUM() Function

The SUM() function returns the total sum of a numeric column

SELECT SUM(total_runs)
FROM deliveries;

This query will return the sum of the total runs from the deliveries table

AVG() Function

The AVG() function calculates the average of a set of values

SELECT AVG(total_runs)
FROM deliveries;

This query will return the average of the total runs column from the deliveries table

MIN() Function

The MIN() aggegate function returns the lowest value (minimum) in a set of non-NULL values.

SELECT MIN(quantity_in_stock)
FROM products;

This query will return the minimum quantity in stock in the products table

MAX() Function

THE MAX() aggregate function returns the highest value (maximum) in a set of non-NULL values

SELECT MAX(quantity_in_stock)
FROM products;

This query will return the maximum quantity in stock in the products table

The aggregate function in SQL is very powerful in the database. It serves the same purposes as their equivalents in MS Excel.

Filtering in queries

One of the most powerful features of a database is the ability to filter data i,e. to select only those records that match certain criteria. For example, suppose we want to see when a particular site was visited. We can select these records from the Visited table by using a WHERE clause in our query.

SELECT * 
FROM Visited
WHERE site = 'google.com';

We use AND, OR and NOT operator to add condition with the WHERE clause and filter.

SELECT *
FROM Deliveries
WHERE ball <= 6 and (season = '2015' or season = '2017');

This query will return all the columns where ball is less than or equal to 6 and season are 2015 or 2017.

We use IN operator to see if a value is in a specific set

SELECT *
FROM matches
WHERE season IN(2015, 2017)

This query returns all columns where the season are 2015 or 2017

We use BETWEEN operator to see if a value is in between some set of operator.

SELECT *
FROM matches
WHERE season IN BETWEEN 2015 AND 2017;

This query return all the columns where the seasons are in between 2015 and 2017

We use LIKE operator with % when we want to filter out characters in that place. It can be used at the beginning, middle or end of the string

SELECT *
FROM matches
WHERE season LIKE '201%';

This query will return all the columns where the season are 2010 to 2017 matches.
We also use DISTINCT to select only the unique values or characters in the table.

GROUP BY AND HAVING

The GROUP BY statement groups rows that have the same values into summary rows like "find the number of customers in each country".
The GROUP BY statement is often used with the aggregate functions to group result-set together.
The HAVING statement is used when we want to add some condition to the GROUP BY statement like selecting some aggregate function

SELECT FIRST_NAME , COUNT(*)
FROM EMPLOYEES 
GROUP BY FIRST_NAME
HAVING COUNT(*) > 1;

This query selects the first name from employees table and group total number of same set first name together with the GROUP BY clause and then using HAVING to select only the count of first name greater than 1

Normalization

Normalization is a database design technique that reduces data redundancy and eliminates undesirable characteristics like Insertion, Update and Deletion Anomalies. Normalization rules divides larger tables into smaller tables and links them using relationships. The purpose of Normalisation in SQL is to eliminate redundant (repetitive) data and ensure data is stored logically.

Basic Database Normal Forms are:

1NF (First Normal Form)

Each table cell should contain a single value
Each record needs to be unique

Primary Key is a single column value used to identify a database record uniquely.
Composite Key is a primary key composed of multiple columns used to identify a record uniquely
Candidate Key SQL is a column or a set of columns that can qualify as a primary key in the database.
Foriegn Key references the primary key of another table means it helpss in connecting different tables with same id data

2NF (Second Normal Form)

Rule 1 - Be in 1NF
Rule 2 - Single Column Primary Key that does not functionally dependant on any subset of candidate key

3NF (Third Normal Form)

In most practical applications, normalization achieves its best in 3rd Normal Form

Rule 1 - Be in 2NF
Rule 2 - Has no transitive functional dependencies
Most database systems are normalized database up to the third normal forms in DBMS.
A primary key uniquely identifies are record in a Table and cannot be null
A foreign key helps connect table and references a primary key

Indexes

The Index in SQL is a special table used to speed up the searching of the data in the database tables.
We use Indexes in SQL because:

SQL Indexes can search information quickly for large databases.
This data structure sorts the data values of columns (fields) either in ascending or descending order. And then, it assigns the entry for each value.

Create an INDEX

In SQL, we can easily create the INDEX using the following CREATE statement:

CREATE INDEX index_name 
ON table_name (column_name);

Here, index_name is the name of that index that we want to create, and table_name is the name of the table on which the index is to be created. The column_name represents the name of the column on which index is to be applied.

Create UNIQUE INDEX

UNIQUE INDEX is the same as the Primary key in SQL. The unique index does not allow selecting those columns which contain duplicates value.
This index is the best way to maintain the data integrity of the SQL tables.

CREATE UNIQUE INDEX index_salary 
ON Employee (Emp_Salary);

The above SQL query creates the unique index index_salary on the Emp_Salary column of the Employee table.

Rename an INDEX

We can easily rename the index of the table in the relational database using the ALTER command.

ALTER INDEX index_Salary 
RENAME TO index_Employee_Salary;

The above SQL query renames the index 'index_Salary' to 'index_Employee_Salary' of the above Employee table

Remove an INDEX

An Index of the table can be easily removed from the SQL database using the DROP command. If you want to delete an index from the data dictionary, you must be the owner of the database or have the privileges for removing it.

DROP INDEX index_salary;

The above query remove the index_salary from the SQL database.

Alter an INDEX

An index of the table can be easily modified in the relational database using the ALTER command.

ALTER INDEX Index_Name 
ON Table_Name REBUILD;

Basic syntax for modifying the Index in SQL

Transactions

A Transaction is a unit of work that is performed against a database. A Transaction is the propagation of one or more changes to the database.

Properties of Transaction are ACID
There are certain commands that are used to control transactions:

COMMIT

The COMMIT command is the transactional command used to save changes invoked by a transaction to the database.

The Following Query will delete those records from the table which have age = 25 and then COMMIT the changes in the database

DELETE FROM customers
WHERE age = 25;
COMMIT;

ROLLBACK

The ROLLBACK command is the transactional command used to undo transactions that have not already been saved to the database.
This command can only be used to undo transactions since the last COMMIT or ROLLBACK command was issued.

The following query will delete those records from the table which have the age = 25 and then ROLLBACK the changes in the database

DELETE FROM customers
WHERE age = 25;
ROLLBACK;

SAVEPOINT

A SAVEPOINT is a point in a transaction when you can roll the transaction back to a certain point without rolling back the entire transaction.
Syntax for SAVEPOINT command is:

SAVEPOINT SAVEPOINT_NAME;

SET TRANSACTION

The SET TRANSACTION command can be used to initiate a database transaction. This command is used to specify characteristics for the transaction that follows
Syntax for SET TRANSAACTION command is:

SET TRANSACTION [ READ WRITE | READ ONLY ];

Locking mechanism

*PostgreSQL locks * restricts users from modifying a row or a PostgreSQL table's contents. Rows that have undergone a DELETE or UPDATE operation will be locked soley until the transaction is finished.

Types of PostgresSQL Locks:

Table-Level Locks - Lock the table specifying the mode of locking and the table name.
Row-Level Locks - PostgreSQL uses locks in every aspect of its functioning to serialize or distribute access to crucial data.
Page-Level Locks - These are of two types Share and Exclusive locks limit read/write access to table pages.
Advisory Locks - When locks are created in PostgreSQL with application-defined meanings
Deadlocks - This happens when two transactions wait for one another to complete their operations. PostgreSQL understands deadlock and breaks them with a ROLLBACK.

One can easily exercise this control and guarentee that only one person is making changes to a row or table at once by using PostgreSQL locking.

Database Isolation Levels

We know that in order to maintain consistency in a database, it follows ACID properties. Among these four properties (Atomicity, Consistency, Isolation, and Durability) Isolation determines how transaction integrity is visible to other users and systems.

The transaction isolation level is defined by the following:

Dirty Read - Situation when a transaction reads data that has not yet been committed.
Non Repeatable read - This happens when the transaction reads the same row twice and gets a different value every time.
Phantom Read - This occurs when two same queries are executed, but the rows retrieved by the two, are different.
Serializable - This is the highest isolation level, when execution of operations in which concurrently executing transactions appears to be serially executing.

Triggers

A SQL Trigger is a database object which happens when an event occurs in a database. For example, a trigger can be set on a record insert in a database table.

There are certain Trigger Points in SQL Trigger:
1) When any DDL operation is done E.g., CREATE, ALTER, DROP
2) For a DML operation. e.g., INSERT, UPDATE, DELETE
3) For a database operation like LOGON, LOGOFF, STARTUP, SHUTDOWN or SERVERERROR

Creating Triggers in SQL

We can create triggers for various kinds of operations.

CREATE TABLE student
(Id integer PRIMARY KEY,
 first_name varchar(50),
 last_name varchar(50),
 full_name varchar(50)
);

Here we will create a trigger to fill in the full name by concatenating the first and last names. So we will expect the trigger to automatically update each row with an additional column attribute bearing the full name.

Display Triggers in SQL

If someone creates a trigger but forgets the trigger's name, then you can find the trigger by running a simple command.

SHOW TRIGGERS LIKE 'stu%'\G;

This command will show you the list of all available triggers matching with the string ‘stu’.

Drop Triggers in SQL

The deletion of a trigger is very straightforward. Just need to run a simple query to delete a trigger from the database.

DROP TRIGGER student_name;

The query to erase the trigger from the database.

Conclusion

Databases are a critical component of many software systems, and understanding these concepts is essential for building and maintaining high-performance, reliable databases. By understanding ACID, CAP Theorem, Joins, Aggregations, Filters in queries, Normalization, Indexes, Transactions, Locking mechanism, Database Isolation Levels and Triggers, developers can build efficient and scalable database systems that meet the needs of their applications.

References

SOLID concepts with Python code samples

Anirban Das — Mon, 20 Feb 2023 06:48:06 +0000

Introduction

SOLID is a set of five principles for writing clean and maintainable code, initially introduced by Robert C. Martin (also known as Uncle Bob). These principles can help you develop code that is easy to understand, test, and modify.

The SOLID principles are:

S - Single-Responsibility Principle (SRP)
O - Open-Closed Principle (OCP)
L - Liskov Substitution Principle (LSP)
I - Interface Segregation Principle (ISP)
D - Dependency inversion Principle (DIP)

In this paper, we will discuss each of the SOLID principles and provide Python code samples to illustrate their usage.

S - Single Responsibility Principle

The Single Responsibility Principle (SRP) states that a class should have only one reason to change. In other words, a class should have only one responsibility.

Example

Here's an example of violating the SRP in Python:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

    def print_area(self):
        area = self.width * self.height
        print(f"The area of the rectangle is {area}")

In this example, we have a Rectangle class that represents a rectangle and has two responsibilities: calculating the area of the rectangle and printing the area to the console. This violates the SRP because a class should have only one responsibility.

To correct this violation, we need to separate the responsibilities into two different classes. Here's an example of how we can correct this violation:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

class RectanglePrinter:
    def __init__(self, rectangle):
        self.rectangle = rectangle

    def print_area(self):
        area = self.rectangle.get_area()
        print(f"The area of the rectangle is {area}")


rectangle = Rectangle(10, 20)
rectangle_printer = RectanglePrinter(rectangle)
rectangle_printer.print_area() # The area of the rectangle is 200

In this corrected example, we have two classes: Rectangle and RectanglePrinter. The Rectangle class has the responsibility of representing a rectangle and calculating its area, while the RectanglePrinter class has the responsibility of printing the area of a rectangle to the console.

By separating the responsibilities of the two classes, we have adhered to the SRP and improved the maintainability and extensibility of our code. If we need to change the way we calculate the area of a rectangle, we can do so without affecting the code that prints the area. Similarly, if we need to change the way we print the area, we can do so without affecting the code that calculates the area.

O - Open-Closed Principle

The Open-Closed Principle (OCP) states that a class should be open for extension but closed for modification. In other words, we should be able to extend the behavior of a class without modifying its source code.

Example

Here's an example of a class violating the OCP:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def get_area(self):
        return 3.14 * self.radius * self.radius

def print_area(shape):
    if isinstance(shape, Rectangle):
        area = shape.get_area()
        print(f"The area of the rectangle is {area}")
    elif isinstance(shape, Circle):
        area = shape.get_area()
        print(f"The area of the circle is {area}")

In this example, we have a Rectangle class and a Circle class that both have a get_area() method to calculate their respective areas. We also have a print_area() function that takes a shape as a parameter and prints its area to the console. The problem with this code is that if we want to add a new shape (e.g., triangle) in the future, we will have to modify the print_area() function to include a new condition for the new shape.

To correct this violation, we need to make our code open for extension but closed for modification. Here's an example of how we can correct this violation:

class Shape:
    def get_area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def get_area(self):
        return 3.14 * self.radius * self.radius

def print_area(shape):
    area = shape.get_area()
    print(f"The area of the shape is {area}")

rectangle = Rectangle(10, 20)
print_area(rectangle) # The area of the shape is 200

circle = Circle(5)
print_area(circle) # The area of the shape is 78.5

In this corrected example, we have created an abstract Shape class that has a get_area() method that is overridden by the concrete classes Rectangle and Circle. We also modified the print_area() function to take any object that implements the Shape interface and call its get_area() method to print its area to the console.

By making our code open for extension but closed for modification, we have adhered to the OCP and improved the maintainability and extensibility of our code. If we need to add a new shape (e.g., triangle) in the future, we can create a new class that implements the Shape interface and pass it to the print_area() function without modifying the function's source code.

L - Liskov Substitution Principle

The Liskov Substitution Principle (LSP) states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. If the sub class changes due to any modification the super class should not get affected.

Example

Here's an example of a violation of the LSP:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def get_width(self):
        return self.width

    def get_height(self):
        return self.height

    def get_area(self):
        return self.width * self.height

class Square(Rectangle):
    def set_width(self, width):
        self.width = width
        self.height = width

    def set_height(self, height):
        self.height = height
        self.width = height

    def get_width(self):
        return self.width

    def get_height(self):
        return self.height

In this example, we have a Rectangle class and a Square class that inherits from the Rectangle class. The problem with this code is that a Square object can be used wherever a Rectangle object is used, but the behavior of a Square object is not the same as that of a Rectangle object. Specifically, a Square object has the same width and height, whereas a Rectangle object can have different width and height.

To correct this violation, we need to ensure that a Square object can be used wherever a Rectangle object is used without causing any unexpected behavior. Here's an example of how we can correct this violation:

class Shape:
    def get_area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def get_width(self):
        return self.width

    def get_height(self):
        return self.height

    def get_area(self):
        return self.width * self.height

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def set_side(self, side):
        self.side = side

    def get_side(self):
        return self.side

    def get_area(self):
        return self.side * self.side

rectangle = Rectangle(10, 20)
print(f"Rectangle area: {rectangle.get_area()}") # Rectangle area: 200
rectangle.set_width(5)
rectangle.set_height(10)
print(f"New rectangle area: {rectangle.get_area()}") # New rectangle area: 50

square = Square(5)
print(f"Square area: {square.get_area()}") # Square area: 25
square.set_side(7)
print(f"New square area: {square.get_area()}") # New square area: 49

In this corrected example, we have created an abstract Shape class that is inherited by the Rectangle and Square classes. We also modified the Rectangle and Square classes to ensure that the behavior of a Square object is the same as that of a Rectangle object. Specifically, we added a set_side() method and a get_side() method to the Square class and overrode the get_area() method to calculate the area of a square.

By ensuring that a Square object can be used wherever a Rectangle object is used without causing any unexpected behavior, we have adhered to the LSP and improved the flexibility and reusability of our code.

I - Interface Segregation Principle

The Interface Segregation Principle (ISP) states that clients should not be forced to depend on interfaces they do not use. In other words, we should separate large interfaces into smaller and more specific ones.

Example

Here's an example of a violation of the ISP:

class Printer:
    def print(self, document):
        pass

    def fax(self, document):
        pass

    def scan(self, document):
        pass

class OldPrinter(Printer):
    def print(self, document):
        print("Printing document: ", document)

    def fax(self, document):
        pass

    def scan(self, document):
        pass

class ModernPrinter(Printer):
    def print(self, document):
        print("Printing document: ", document)

    def fax(self, document):
        print("Faxing document: ", document)

    def scan(self, document):
        print("Scanning document: ", document)

In this example, we have a Printer interface with three methods: print(), fax(), and scan(). We also have two classes that implement this interface: OldPrinter and ModernPrinter. The problem with this code is that the OldPrinter class does not support the fax() and scan() methods, but it still has to implement these methods because they are part of the Printer interface. This violates the ISP because the client of the OldPrinter class is forced to depend on methods it does not use.

To correct this violation, we need to separate the Printer interface into smaller interfaces that are more focused on specific functionalities. Here's an example of how we can correct this violation:

class Printer:
    def print(self, document):
        pass

class Fax:
    def fax(self, document):
        pass

class Scanner:
    def scan(self, document):
        pass

class OldPrinter(Printer):
    def print(self, document):
        print("Printing document: ", document)

class ModernPrinter(Printer, Fax, Scanner):
    def print(self, document):
        print("Printing document: ", document)

    def fax(self, document):
        print("Faxing document: ", document)

    def scan(self, document):
        print("Scanning document: ", document)

old_printer = OldPrinter()
old_printer.print("This is an old printer") # Printing document:  This is an old printer

modern_printer = ModernPrinter()
modern_printer.print("This is a modern printer") # Printing document:  This is a modern printer
modern_printer.fax("This is a fax") # Faxing document:  This is a fax
modern_printer.scan("This is a scan") # Scanning document:  This is a scan

In this corrected example, we have separated the Printer interface into three smaller interfaces: Printer, Fax, and Scanner. We also modified the OldPrinter and ModernPrinter classes to implement only the interfaces they need. The OldPrinter class now only implements the Printer interface, and the ModernPrinter class implements all three interfaces. This ensures that the client of the OldPrinter class is not forced to depend on methods it does not use, and that the ModernPrinter class supports all three methods.

By separating the Printer interface into smaller, more focused interfaces, we have adhered to the ISP and improved the flexibility and reusability of our code.

D - Dependency Inversion Principle

The Dependency Inversion Principle (DIP) states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.

Example

Here's an example of a violation of the DIP:

class PaymentProcessor:
    def process_payment(self, payment):
        if payment.type == "credit_card":
            credit_card = CreditCard()
            credit_card.process_payment(payment)
        elif payment.type == "paypal":
            paypal = PayPal()
            paypal.process_payment(payment)

class CreditCard:
    def process_payment(self, payment):
        print("Processing credit card payment...")

class PayPal:
    def process_payment(self, payment):
        print("Processing PayPal payment...")

In this example, the PaymentProcessor class depends on the CreditCard and PayPal classes. The PaymentProcessor class creates instances of these classes and calls their process_payment() methods directly. This violates the DIP because the PaymentProcessor class depends on low-level modules (CreditCard and PayPal) instead of abstractions.

To correct this violation, we need to invert the dependencies by introducing an abstraction (interface) between the PaymentProcessor and the low-level modules. Here's an example of how we can correct this violation:

class PaymentProcessor:
    def __init__(self, payment_gateway):
        self.payment_gateway = payment_gateway

    def process_payment(self, payment):
        self.payment_gateway.process_payment(payment)

class PaymentGateway:
    def process_payment(self, payment):
        pass

class CreditCardGateway(PaymentGateway):
    def process_payment(self, payment):
        print("Processing credit card payment...")

class PayPalGateway(PaymentGateway):
    def process_payment(self, payment):
        print("Processing PayPal payment...")

credit_card_gateway = CreditCardGateway()
payment_processor = PaymentProcessor(credit_card_gateway)
payment_processor.process_payment(4) # Processing credit card payment...

paypal_gateway = PayPalGateway()
payment_processor = PaymentProcessor(paypal_gateway)
payment_processor.process_payment(7) # Processing PayPal payment...

In this corrected example, we have introduced an PaymentGateway interface between the PaymentProcessor and the low-level modules. The PaymentProcessor class now depends on the PaymentGateway interface instead of the CreditCard and PayPal classes. The PaymentGateway interface has a single method process_payment() which is implemented by the CreditCardGateway and PayPalGateway classes. The PaymentProcessor class now receives an instance of the PaymentGateway interface through its constructor and calls the process_payment() method on this instance to process the payment.

By introducing an abstraction (interface) between the PaymentProcessor and the low-level modules, we have inverted the dependencies and adhered to the DIP. This makes the PaymentProcessor class more flexible and reusable, and allows us to easily add new payment gateways without modifying the PaymentProcessor class.

Conclusion

In conclusion, the SOLID principles are a set of guidelines that help us write code that is easier to maintain, extend, and test. By following these principles, we can create code that is more modular, more decoupled, and more reusable, which can lead to better software design and higher productivity.

References

1) Coding with Johan Blogs
2) Code Specialist
3) Damavis SOLID blog
4) Levelup gitconnected
5) Github gist on SOLID

Objects and Object Oriented Programming

Anirban Das — Thu, 16 Feb 2023 08:40:49 +0000

Nowadays the modern software development resides around objects and its oriented programming for a good reason. As it gives a lot of benefits over the old paradigm of procedural programming.

Python is an object oriented programming language
Object orient programming is a way to design the program using classes and objects.
The main concepts of OOPs is to bind the data and the functions that work on the data together as a single unit os that no other part of the code can access this data
The four concepts that contructs the OOP are data abstraction, polymorphism, encapsulation and inheritance

Main concepts of OOP

Class

Class consists of a collection of objects
Classes are known as the blueprint of objects
Classes have there own attributes and methods that has the accessibility only by the objects of that class
We can initialize the attributes of a Class using init method

class Mountblue:
    def __init__(self, name, company):
        self.name = name
        self.company = company

    def some_method_to_work(some arguments):
        # Statements to execute
        # return statements

Object

Objects are the instance of a class
Object are just like real world entities like a car, boy, girl, etc
An object consists of methods and attributes
Object of a class consist of self parameter which represents the attributes of its class.
We can use any parameters in any methods belong to the same class.

class Car:
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def show_props(self):
        print(self.brand, self.model)
        print(self.color)

s = Car("Tata", "Nano", "Blue")
s.show_props()

## output: 
Tata Nano
Blue

Data Abstraction

Data Abstraction or data hiding is to avoid details of an object which are not used in the current task
For example, if we are driving a car, we do not need to know the mechanism of how the car works when we push gear, acceleration or brakes.
For Data hiding: We use double underscore("__") before the attributes names and those attributes will not be directly visible outside.

class MyClass:
    __thisvariablehidden = 0
    def adder(self, increment):
    self.__thisvariablehidden += increment
    print(self.__thisvariablehidden)

object1 = MyClass()
object1.add(200)
object1.add(72)

print(object1.__thisvariablehidden)
# output: 200
#          72

error:
MyClass instance has 
no attribute '__thisvariablehidden'

Encapsulation

OOP allows us to encapsulate data and behaviour within objects.
This means that we can hide implementation details and only the interface is visible for the other parts of the program
It helps us for code maintainability and updation the code over time
Protected members(single underscore"_") are those classes which cannot be accessed outside the class but can be accessed from within the class
Private members(double underscore"__") are the class members that cannot be accessed outside the class as well as inside of any base class. Completely private protected file

class Account:
    def __init__(self, balance):
        self.__balance = balance # private attribute

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

    def get_balance(self):
        return self.__balance

# The __balance attribute is marked as private by using double underscore
# By using this the balance is secured 
a = BankAccount(50)
a.deposit(50)
print(a.get_balance())
# 100

Polymorphism

Polymorphism means one type having many forms
It allows us to write code that can work with objects of different classes, as long as they have common interface
With polymorphism we can can the code more flexible and reusable

def add(x, y, z = 0):
    return z + y + z

print(add(4, 5))
print(add(4, 5, 6))
# output : 9
#          15

Method Overriding

It allows a subclass or child class to provide a specific kind of implementation of a method that is already provided by one of its super-classes or parent classes.
When a method in a subclass has the same name, same parameters or signature and same return type as a method in its super-class, then the method in the subclass is said to override the method in the super-class.

class Parent():
    def __init__(self):
        self.value = "Inside Parent"

    def show(self):
        print(self.value)

class Child(Parent):
    def __init__(self):
        self.value = "Inside Child"
    def show(self):
        print(self.value)

obj1 = Parent()
obj2 = Child()

obj1.show()
obj2.show()
# Output: Inside Parent
#         Inside Child

Method Overloading

Two or more methods have the same name but different numbers of parameters or different types of parameters, or both.
The problem with method overloading in python is that we may overload the methods but can only use the latest defined method.

def product(a, b):
    d = a * b
    print(d)

def product(a, b, c):
    d = a * b * c
    print(d)

product(3, 4, 2)
# output : 24

Inheritance

Inheritance is the capability of one class to derive or inherit the properties from parent class.
This can be useful when we have several classes that share common properties or behavior
It provides reusability of a code and allows us to add more features to a class without modifying it.

Types of Inheritance

1. Single Inheritance

New class is called the derived class or subclass, and the existing class is called the base class or superclass.
The derived class inherits al the properties of the base class

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def make_sound(self):
        print(f"{self.name} says {self.sound}!")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "Woof")

dog = Dog("Tommy")

dog.make_sound()
# output : "Tommy says Woof!"

2. Multi-level Inheritance

In this inheritance a derived class is created based on another derived class, which is based on a base class.

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def make_sound(self):
        print(f"{self.name} says {self.sound}!")4

class DomesticAnimal(Animal):
    def __init__(self, name, sound, breed):
        super().__init__(name, sound)
        self.breed = breed

    def show_breed(self):
        print(f"{self.name} is a {self.breed}.")

class Dog(DomesticAnimal):
    def __init__(self, name, breed):
        super().__init__(name, 'Woof', breed)

dog = Dog("Tommy", "German Spitz")

dog.make_sound()
# output : "Tommy says Woof!"
dog.show_breed()
# output : "Tommy is a German Spitz"

References :

Python String Methods

Anirban Das — Thu, 16 Feb 2023 06:10:40 +0000

Python has a set of built-in methods that you can use on strings.
All string methods returns new values. They do not change the original string.

1) capitalize()

The capitalize() converts the first character to upper case.

txt = "hello, and welcome to my world."
x = txt.capitalize()
print(x) # Hello, and welcome to my world.

2) count(value)

The count() method returns the number of times a specified value appears in the string.

txt = "I love apples, apple are my favorite fruit"
x = txt.count("apple")
print(x) # 2

3) find(value)

Searches the string for a specified value and returns the position of where it was found.

The find() method finds the first occurrence of the specified value.
It returns -1 if the value is not found.

txt = "Hello, welcome to my world."
x = txt.find("welcome")
print(x) # 7

4) String Slicing

To obtain a substring from a given string we use slicing.

We need to specify the start index and the end index seperated by a colon.

name = "Hey, This is Anirban"
print(name[13:20]) # Anirban
print(name[13:]) # Anirban
print(name[-7:]) # Anirban

5) replace(oldvalue, newvalue)

The replace() method returns a string where a specified value is replaced with another value given.

txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x) # I like apples

6) strip(characters)

The strip() method removes any whitespaces at the beginning and ending of a string and returns the trimed string.

Optionally we can even give a character to be removed from the string.

txt = "   Mount Blue   "
x = txt.strip()
print(x) # Mount Blue

7) upper()

The upper() converts a string into uppercase

txt = "Hello my friends"
x = txt.upper()
print(x) # HELLO MY FRIENDS

8) lower()

The lower() converts a strubg into lowercase

txt = "Hello my FRIENDS"
x = txt.lower()
print(x) # hello my friends

9) join(iterable)

The join() converts the elements of an iterable into a string

my_tuple = ("John", "Anirban", "Roshan")
x = ' '.join(my_tuple)
print(x) # John Anirban Roshan

10) swapcase()

The swapcase() swap the case of the elements of a string from upper to lower and vice versa.

name = "Anirban"
x = name.swapcase()
print(x) # aNIRBAN

11) islower() and isupper()

islower() returns true if all the characters in the string are in lowercase

isupper() returns true if all the characters in the string are in uppercase

name = "anirban"
print(name.islower()) # True
print(name.isupper()) # False

12) isalnum(), isalpha() and isdigit()

isalnum() returns true if all the characters of the string are alphanumeric in nature

isalpha() returns true if all the characters of the string are alphabetic in nature

isdigit() returns true if all the characters of the string are digits

name = "Company12"
print(name.isalnum()) # True
print(name.isalpha()) # False
print(name.isdigit()) # False

13) title()

The title() converts the first character of each word to upper case

txt = "Welcome to my world"
x = txt.title()
print(x) # Welcome To My World

References:

Python Array List Methods

Anirban Das — Thu, 16 Feb 2023 05:01:30 +0000

Python has a set of built-in methods that you can use on lists/arrays.

1) append(elmnt)

Adds an element at the end of the list

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits) # ['apple', 'banana', 'cherry', 'orange']

2) clear()

Removes all the elements from the list

fruits = ['apple', 'banana', 'cherry', 'orange']
fruits.clear()
print(fruits) # []

3) copy()

Returns a copy of the list

fruits = ["apple", "banana", "cherry"]
x = fruits.copy()
print(x) # ['apple', 'banana', 'cherry']

4) count(value)

Returns the number of elements with the specified value

arr = [1, 4, 2, 9, 7, 8, 9, 3, 1]
x = arr.count(9)
print(x) # 2

5) extend(iterable)

Add the elements of a list (or any iterable), to the end of the current list

fruits = ['apple', 'banana', 'cherry']
cars = ['Ford', 'BMW', 'Volvo']
fruits.extend(cars)
print(fruits) # ['apple', 'banana', 'cherry', 'Ford', 'BMW', 'Volvo']

6) index(elmnt)

Returns the index of the first element with the specified value

numbers = [4, 55, 64, 32, 16, 32]
x = numbers.index(32)
print(x) # 3

7) insert(pos, elmnt)

Adds an element at the specified position

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits) # ['apple', 'orange', 'banana', 'cherry']

8) pop(pos)

Removes the element at the specified position

fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits) # ['apple', 'cherry']

9) remove(elmnt)

Removes the first item with the specified value

fruits = ['apple', 'banana', 'cherry']
fruits.remove("banana")
print(fruits) # ['apple', 'cherry']

10) reverse()

Reverses the order of the list

fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits) # ['cherry', 'banana', 'apple']

11) sort(reverse=True|False, key=myFunc)

The sort() method sorts the list ascending by default.

cars = ['Ford', 'BMW', 'Volvo']
cars.sort()
print(cars) # ['BMW', 'Ford', 'Volvo']

References:

What is ls, pwd, chmod, chown in shell?

Anirban Das — Thu, 02 Feb 2023 04:29:07 +0000

ls - list directory contents

When we have to list the directory contents we use ls command. Some common flags used with ls are:

ls [flags] [File]

-l: Use a long listing format, showing details such as permissions, owner, group, size, and date modified
-a: Show hidden files, which are files that start with a dot (.)
-h: Show sizes in human-readable format, for example, 1K, 20K, 80M instead of numbers in bytes
-t: It sort all the files by modification time, the new modification comes first.
-r: Reverse the order of the sort, for example, sort files by modification time, oldest first

pwd - prints the name of current or working directory

pwd

We use pwd command when we want to display the absolute path of the current working directory.

rm - remove files or directories

rm is used to delete files or directories. Be careful when using rm, as there is no trash bin or undo for deleted files.

rm [flags](optional) [File]

Some of the useful flags are:

-f: Force removal, do not prompt for confirmation
-r: Remove directories and their contents recursively

chmod - change file mode bits

When we have to change the permissions of any files and directories chmod command is used.

chmod [permission_elements] [filename/directoryname]

Some of the basic option we use with chmod for changing permissions are:

u: User/owner permissions
g: Group permissions
o: Other (world) permissions
+: Add permission
-: Remove permission
-R: Operate on files and directories recursively

we can also use decimal number ranging between 0-7 for each element of the permission.
The permission in decimal format are:

4 - read
2 - write
1 - execute
6 - read and write
5 - read and execute
3 - write and execute
0 - no permission

chown - change owner of the file and group

chown is used to change the owner and/or group of a file.

if we want to change the user ownership of given file/directory (root access needed)

chown [username] [filename/directory]

change both user and group:

chown [username:groupname] [filename/directory]

-R: Operate on files and directories recursively