DEV Community: Shubham Kumar Gupta

Django Concepts

Shubham Kumar Gupta — Tue, 04 Apr 2023 10:20:53 +0000

1. Settings file

What is secret key?

The secret key is a string used to provide cryptographic signing and encryption in Django.
It is used to secure cookies, session data, and other sensitive information.
It is recommended that this key is kept secret and not shared publicly.

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

Django comes with a number of built-in apps, including admin, auth, contenttypes, sessions, messages, and staticfiles.
There are also many third-party apps available that can be easily installed via pip.

What is middleware? What are different kinds of middleware?

Middleware is a way to add extra functionality to the request/response processing in Django.
There are different types of middleware, including process_request, process_view, process_exception, and process_response.
Security middleware can help prevent common vulnerabilities like CSRF, XSS, and Clickjacking.

Django Security

Django has several built-in security features to help protect against common web application vulnerabilities. Some of these include:

CSRF protection: Cross-site request forgery protection helps prevent unauthorized actions on behalf of a user.
XSS protection: Cross-site scripting protection helps prevent injection attacks that can execute malicious code in a user's browser.
Clickjacking protection: Clickjacking protection helps prevent attackers from tricking users into clicking on hidden or disguised elements.

CSRF

CSRF (Cross-site request forgery) is a form of security breach in which an unauthorized user can perform actions on behalf of an unsuspecting user.

XSS

Cross-site scripting (XSS) is a type of attack where an attacker can inject malicious code into a website, which can then be executed by other users who view the page. Django includes built-in XSS protection to help prevent these attacks.

Clickjacking

Clickjacking is a type of attack where an attacker tricks a user into clicking on something they didn't intend to click on. Django includes built-in clickjacking protection to help prevent these attacks.

Other middleware

There are many other types of middleware available for Django, including caching middleware, authentication middleware, and compression middleware.

What is WSGI?

The WSGI (Web Server Gateway Interface) is a set of guidelines that define a uniform interface between web servers and web applications.
Django includes a built-in WSGI server that can be used for development.
But for production use, it is recommended to use a dedicated web server like Apache or Nginx with a WSGI interface like mod_wsgi or uWSGI.

2. Models file

What is ondelete Cascade?

Ondelete Cascade is a feature in Django that allows you to specify how related objects should be treated when the parent object is deleted.
When a parent object is deleted, the Ondelete Cascade option will automatically delete any related objects as well.

Fields and Validators

Django provides a variety of fields and validators that can be used in your models to define the structure of your database tables.
Some of the most common fields include CharField, IntegerField, DateField, DateTimeField, and ForeignKey.
Validators are used to validate the data entered by the user before it is saved to the database.
Some common validators include MaxValueValidator, MinValueValidator, and RegexValidator.

Python module vs Python class

In Python, a module is a file containing Python definitions and statements, while a class is a blueprint for creating objects.
In Django models, a module typically contains multiple classes, each representing a database table.
The module itself is simply a file that contains these class definitions.
Each class within the module represents a specific database table, with the class attributes defining the table fields and their data types.

3. Django ORM

Using ORM queries in Django Shell

The Django shell provides a way to interact with your database using Python code.
You can use ORM queries to retrieve and manipulate data in the shell just like you would in a Python script.

Turning ORM to SQL in Django Shell

You can use the query attribute of a Django ORM query to view the corresponding SQL query that will be executed.
For example, if you have a QuerySet called my_queryset, you can view the corresponding SQL query by calling print(my_queryset.query).

What are Aggregations?

Aggregations in Django are a way to perform calculations on a set of objects and return a single value.
Some common aggregations include count, sum, avg, min, and max.

What are Annotations?

Annotations in Django allow you to add extra information to each object in a QuerySet.
You can use annotations to add calculated fields, perform subqueries, and more.

What is a migration file? Why is it needed?

A migration file in Django is a Python script that describes the changes that need to be made to the database schema.
It is created using the makemigrations command and is used to update the database schema when changes are made to your models.

What are SQL transactions?

SQL transactions are a way to ensure that multiple SQL statements are executed as a single, atomic operation.
This helps to ensure data consistency and prevent race conditions.
Transactions can be started using SQL commands like BEGIN and COMMIT.

What are atomic transactions?

In Django, atomic transactions are a way to ensure that multiple ORM operations are executed as a single, atomic operation.
This helps to ensure data consistency and prevent race conditions.
Atomic transactions can be started using the atomic decorator or context manager.

HTML-CSS CONCEPTS

Shubham Kumar Gupta — Fri, 24 Feb 2023 12:45:20 +0000

BOX MODEL

The CSS box model surrounds every HTML element with a rectangular box.
It consists of four parts: content, padding, border, and margin.
- Content: The actual text or image within the element.
- Padding: The space between the content and the border.
- Border: Line that surrounds the padding.
- Margin: The space between the border and adjacent HTML elements.
Properties of a CSS box include width, height, padding, border, and margin.
- Width and height set the size of the content box.
- Padding can be set for each side of the element using padding-top, padding-right, etc.
- Border can be set using border-width, border-style, and border-color properties.
- Margin can be set using margin-top, margin-right, etc.
The CSS box model can be implemented using a combination of these properties.
CSS Box model is essential for creating visually appealing designs on web pages.

.box {
  width: 200px;
  height: 200px;
  padding: 20px;
  border: 1px solid black;
  margin: 10px;
}

INLINE VS BLOCK ELEMENTS

1. BLOCK ELEMENTS

Block elements take up the entire width of their container and stack vertically.
Examples of block elements include <div>, <p>, <h1>, <form>, <ul>, <ol>, and <li>.
Block elements can have margins, padding, and borders applied to them.
Block elements can be positioned using CSS.

2. INLINE ELEMENTS

Inline elements do not start a new line by default and only take up as much width as necessary.
Examples of inline elements include <span>, <a>, <strong>, <em>, <img>, and <input>.
Inline elements cannot have margins or padding applied to them but can have borders.
Inline elements can be positioned using CSS, but their position is relative to the text around them.

POSITIONING: RELATIVE/ABSOLUTE

1. RELATIVE POSITIONING

Positioned relative to its normal position in the document flow.
Takes up space in the normal document flow.
Can be moved using top, bottom, left, and right properties.
New position is relative to its original position.

2. ABSOLUTE POSITIONING

Positioned relative to nearest positioned ancestor or initial containing block.
Taken out of the normal document flow and does not take up space.
Can be moved using top, bottom, left, and right properties.
New position is relative to nearest positioned ancestor.

COMMON CSS STRUCTURAL CLASSES

.container: Creates a wrapper for the content on a web page with a fixed width to center the content and provide padding.
.row: Creates a row of columns within a container.
.col: Creates a column within a row, with a specified width or auto width.
.clearfix: Clears floated elements within a container.
.hidden: Hides an element from view by setting its display property to "none".
.visible: Shows a hidden element by overriding its display property to "block" or "inline".
.padding, .padding-top, .padding-right, .padding-bottom, .padding-left: Applies padding to an element, with different values to create space around the content.
.margin, .margin-top, .margin-right, .margin-bottom, .margin-left: Applies margin to an element, with different values to create space between the elements.
.float-left, .float-right, .float-none: Floats an element to the left, right, or none, respectively.
.text-truncate: Truncates long text within an element with ellipsis.

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 CSS selector is in targeting an HTML element.
Four values are used to calculate specificity:
- 0 points for universal selector(*) and combinators(+, >, ~),
- 1 point for element selectors(e.g. h1, div, input), pseudo-elements(:after, :before), and class selectors(.example),
- 10 points for ID selectors(#example), and
- 1000 points for inline styles.
When multiple styles are applied to an element, the style with the highest specificity value takes precedence.
If two selectors have the same specificity value, the one defined last in the CSS document takes precedence.

CSS RESPONSIVE QUERIES

CSS responsive queries are also called media queries.
They allow you to apply CSS styles based on the characteristics of the device or browser being used to view your website.
They are written using the @media rule.
We can use queries to target specific device sizes, such as smartphones or tablets, using min-width and max-width.
- @media screen and (max-width: 767px): Commonly used for smartphones.
- @media screen and (min-width: 768px) and (max-width: 1023px): Commonly used for tablets.
- @media screen and (min-width: 1024px): Commonly used for PCs.

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

<title>: Defines the title of the HTML document.
<meta charset="utf-8">: Specifies the character encoding used in the HTML document.
<meta name="viewport" content="width=device-width, initial-scale=1.0>: Sets the viewport width to the width of the device and sets the initial zoom level to 1.0.
<meta name="description" content="description of your webpage">: Provides a brief description of the HTML document.
<meta name="keywords" content="comma-separated list of keywords">: Specifies a comma-separated list of relevant keywords.
<link rel="stylesheet" href="stylesheet.css">: Links an external stylesheet to apply styles to HTML elements.

CSS 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.

REFERENCES

SQL CONCEPTS

Shubham Kumar Gupta — Wed, 22 Feb 2023 05:06:05 +0000

ACID

ACID stands for: Atomicity, Consistency, Isolation, and Durability.
They help to ensure that the databse transactions are executed reliably and consistently.

1. ATOMICITY

A transaction is considered to be atomic if either all of its operations are committed or none of them are.
If any of the statements within the transaction fails, the transaction will be rolled back to the previous state.
We can implement atomicity, using "BEGIN", "COMMIT", and "ROLLBACK" statements.

BEGIN;
INSERT INTO accounts (account_number, balance) VALUES (123, 1000);
UPDATE accounts SET balance = 800 WHERE account_number = 123;
COMMIT;

BEGIN;
UPDATE customers SET first_name = 'John' WHERE id = 1;
UPDATE customers SET first_name = 'Jane' WHERE id = 99999; -- this will fail
ROLLBACK;

2. CONSISTENCY

Consistency ensures that a transaction takes the database from one valid state to another.
The database should always remain in a consistent state, even if any errors occur during a transaction.
We can implement consistency using constraints, such as primary and foreign keys, NOT NULL & UNIQUE.

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

3. ISOLATION

Isolation ensures that transactions are executed independently of one another.
A transaction should not be affected by any other transactions that are running concurrently.
We can implement isolation using isolation levels.

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SELECT balance FROM accounts WHERE account_number = 123;
UPDATE accounts SET balance = balance - 100 WHERE account_number = 123;
COMMIT;

4. DURABILITY

Durability ensures that once a transaction is committed, its changes are permanent and cannot be lost.
Even in the event of a power failure or system crash, the changes made by a committed transaction should be retained.
PostgreSQL implements durability itself by using write-ahead logging (WAL).
WAL records all changes to the database in a separate file before they are written to the database itself.

CAP THEOREM

A distributed system is a collection of independent computers that communicate with each other to achieve a common goal.
In a distributed system, the computers, which are also called nodes, are connected through a network and work together as a single system.
The CAP theorem states that in a distributed system, you can only have two out of three of the following: consistency, availability, and partition tolerance.
In practice, this means that you can only prioritize two of these three attributes, and have to compromise on the third.

1. CONSISTENCY

Consistency means that all nodes in the system see the same data at the same time.
If you write data to one node, all other nodes will immediately see the same data.

2. AVAILABILITY

Availability means that the system continues to function and provide services to users, even in the presence of failures or faults.
If a node in a distributed system fails, the system should be designed to quickly route traffic to other available nodes, so that users can continue to access the system without interruption.

3. PARTITION TOLERANCE

Partition Tolerance means that the system can continue to function even when there is a network partition or a loss of network connectivity between nodes in the system.
Network partitions can occur when nodes in the system cannot communicate with each other, either due to a physical separation or a network failure.

JOINS

Join is used to combine rows from two or more tables based on a related column between them.
There are several types of joins in SQL, including inner join, left join, right join, and full outer join.

Suppose we have two tables, employees, and departments:

employees table

id	name	department
1	John	1
2	Jane	2
3	Bob	1

departments table

id	name
1	Accounting
2	Marketing

1. INNER JOIN

The inner join returns only the rows that have matching values in both tables.

SELECT employees.id, employees.name, departments.name
FROM employees
INNER JOIN departments ON employees.department = departments.id;

id	amount	name
1	100	John
2	200	Jane

2. LEFT JOIN

The left join returns all the rows from the left table and the matched rows from the right table.

SELECT orders.id, orders.amount, customers.name
FROM orders
LEFT JOIN customers ON orders.customer_name = customers.name;

id	amount	name
1	100	John
2	200	Jane
3	150	NULL

3. RIGHT JOIN

The right join returns all the rows from the right table and the matched rows from the left table.

SELECT orders.id, orders.amount, customers.name
FROM orders
RIGHT JOIN customers ON orders.customer_name = customers.name;

id	amount	name
1	100	John
2	200	Jane
NULL	NULL	Alice

4. FULL OUTER JOIN

The full outer join returns all the rows from both tables and null values for any non-matching rows.

SELECT orders.id, orders.amount, customers.name
FROM orders
FULL OUTER JOIN customers ON orders.customer_name = customers.name;

id	amount	name
1	100	John
2	200	Jane
3	150	NULL
NULL	NULL	Alice

AGGREGATIONS, FILTERS IN QUERIES

1. AGGREGATIONS

Aggregations are used to summarize data in a dataset.
Aggregations are often used with the GROUP BY and HAVING clauses to group the data by a certain field.
Some commonly used aggregatuons in SQL are COUNT(), SUM(), AVG(), MAX(), MIN().

SELECT COUNT(*) FROM my_table;

SELECT SUM(sales) FROM my_table;

SELECT AVG(sales) FROM my_table;

SELECT MAX(sales) FROM my_table;

SELECT MIN(sales) FROM my_table;

SELECT category, AVG(price) as average_price
FROM products
GROUP BY category
HAVING AVG(price) > 80;

2. FILTERS

Filters are used to select specific rows from a table based on certain conditions.
We can filter data in SQL by using the WHERE clause in a SELECT statement.

SELECT category, price
FROM products
WHERE price >50;

We can also write SQL query that use both aggregations and filters.

SELECT category, AVG(price) as average_price
FROM products
WHERE price > 50
GROUP BY category
HAVING AVG(price) > 80;

NORMALIZATION

Normalization is organizing a database's tables and columns to reduce redundancy and dependency, and improve data integrity.
It involves breaking down a larger table into smaller tables, each with its own unique purpose and set of columns.
There are primarily six types of normalization in SQL namely, 1NF, 2NF, 3NF, and BCNF.

1. 1NF

In 1NF, columns cannot contain multiple values or sets of values.
The table below violates 1NF because the "Phone Numbers" column contains multiple values:

Employee ID	Name	Phone Numbers
1	John Smith	555-1234, 555-5678
2	Jane Doe	555-2345

To normalize this table, we would create a new table called "Employee_Phone".

Employee ID	Phone Number
1	555-1234
1	555-5678
2	555-2345

2. 2NF

In 2NF, a table must be in 1NF and all non-key columns must be functionally dependent on the primary key.
The table below violates 2NF because the "Product Name" and "Product Price" columns are not functionally dependent on the primary key.

Order ID	Product ID	Product Name	Product Price
1	1001	Widget	10.00
1	1002	Gadget	20.00
2	1003	Thing	15.00

To normalize this table, we would create a new table called "Products" with the following columns:

Product ID	Product Name	Product Price
1001	Widget	10.00
1002	Gadget	20.00
1003	Thing	15.00

We would update the "Order_Details" table to reference the "Products" table by "Product ID":

Order ID	Product ID
1	1001
1	1002
2	1003

3. 3NF

In 3NF, a table must be in 2NF and all non-key columns must be mutually independent.
The table below violates 3NF because the "Email Address" and "Phone Number" columns are not mutually independent, as both are related to contact information.

Employee ID	Email Address	Phone Number
1	john@example.com	555-1234
2	jane@example.com	555-2345

To normalize this table, we would create two new tables called "Employee_Email" and "Employee_Phone", each with its own unique set of columns:

Employee ID	Email Address
1	john@example.com
2	jane@example.com

Employee ID	Phone Number
1	555-1234
2	555-2345

4. BCNF

A table is in BCNF if it doesn't have any overlapping candidate keys.
The table below violates BCNF because "Department ID" cannot uniquely determine the salary of an employee because multiple employees can belong to the same department and have different salaries.

Employee ID	Employee Name	Department ID	Department Name	Salary
1	John	1	Sales	5000
2	Mary	2	Marketing	6000
3	Alex	1	Sales	5500

To normalize this table, we need to split it into two separate tables: "Employee" and "Department", where "Employee" has a foreign key to "Department".

Employee
Employee ID (PK)
Employee Name
Department ID (FK)
Salary

Department
Department ID (PK)
Department Name

INDEXES

Indexes improve query performance by reducing the number of disk reads necessary to satisfy a query.
An index is a data structure that allows PostgreSQL to look up rows in a table quickly based on the values in one or more columns.
As records are added, modified, or deleted, the space allocated to the index may become fragmented, which can slow down queries.
Rebuilding the index can remove fragmentation and improve performance.

Example to create an index on a single column:

CREATE INDEX name_idx ON customers (last_name);

Example to create an index on multiple columns:

CREATE INDEX name_idx ON customers (last_name, first_name);

Example to remove an index:

DROP INDEX name_idx;

Example to rebuild an existing index:

ALTER INDEX name_idx ON customers REBUILD;

TRANSACTIONS

A transaction is a sequence of SQL statements that are executed as a single unit of work.
Transactions ensure that if any part of the transaction fails, the entire transaction is rolled back so that the database remains in a consistent state.
A transaction can span multiple SQL statements and multiple connections, as long as they all use the same transaction ID.
Transactions have four standard properties, ACID (Atomicity, Consistency, Isolation, and Durability).

LOCKING MECHANISM

Locking ensures that multiple transactions do not interfere with each other, and that data remains consistent.
There are two main types of locks in SQL: Shared Locks & Exclusive Locks.

1. Shared Locks

A shared lock allows multiple transactions to read the same data concurrently, but only one transaction can modify the data at a time.

ID	Name	Salary
1	Alice	5000
2	Bob	6000

Transaction T1 wants to read Alice's salary, and transaction T2 wants to read Bob's salary.
Both transactions will acquire a shared lock on the table concurrently to prevent other transactions from modifying the data while it is being read.

2. Exclusive Locks

An exclusive lock allows a single transaction to modify the data while blocking all other transactions from reading or modifying it.

ID	Name	Salary
1	Alice	5000
2	Bob	6000

Transaction T1 wants to read Alice's salary, and transaction T2 wants to read Bob's salary.
Both transactions will acquire an exclusive lock on the table one by one to prevent other transactions from reading or modifying the data while it is being updated.
In the exclusive lock, T2 was blocked while waiting for T1 to release its exclusive lock causing a deadlock.
Deadlocks occur when two or more transactions are waiting for each other to release locks, leading to a situation where none of the transactions can proceed.
To avoid deadlocks, PostgreSQL provides deadlock detection and resolution mechanisms, such as timeout limits or rolling back transactions.

DATABASE ISOLATION LEVELS

Isolation levels define how concurrent transactions are managed when accessing the same data.
There are four standard isolation levels defined in SQL: Read Uncommitted, Read Committed, Repeatable Read, and Serializable.
Consider the following table:

ID	Name	Salary
1	Alice	5000
2	Bob	6000

1. Read Uncommitted

It allows transactions to read uncommitted changes made by other transactions leading to dirty reads.
If transaction T1 updates Bob's salary to 7000, and transaction T2 reads the data at the same time, T2 will see the updated salary of 7000 even though it has not been committed yet.

2. Read Committed

It ensures that a transaction can only read committed data.
If transaction T1 updates Bob's salary to 7000, and transaction T2 reads the data at the same time, T2 will see the original salary of 6000 until T1 commits the changes.

3. Repeatable Read

It ensures that a transaction can read the same data multiple times and receive consistent results preventing non-repeatable reads.
If transaction T1 reads all employees with a salary greater than 5500, and transaction T2 inserts a new employee with a salary of 5600, T1 will not see the new employee even if it reads the data again.

4. Serializable

It ensures that transactions are completely isolated from each other by locking, and each transaction appears to execute in isolation preventing phantom reads.
It can also lead to longer wait times and decreased concurrency.
If transaction T1 inserts a new employee with a salary of 5600, and T2 reads all employees with a salary greater than 5500, T2 will be locked from reading data until T1 commits the changes.

TRIGGERS

A trigger is a statement that is executed automatically by the system as a side effect of a modification to the database.
To design a trigger mechanism, we must specify the conditions under which the trigger is to be executed, and
Specify the actions to be taken when the trigger executes

Example of a function to be triggered:

CREATE OR REPLACE FUNCTION calculate_marks()
RETURNS TRIGGER AS $$
BEGIN
    NEW.total := NEW.subj1 + NEW.subj2 + NEW.subj3;
    NEW.per := NEW.total * 60 / 100;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

Example to create a trigger for the above function:

CREATE TRIGGER stud_marks
BEFORE INSERT ON Student
FOR EACH ROW
EXECUTE FUNCTION calculate_marks();

Insert query:

INSERT INTO Student VALUES(0, "ABCDE", 20, 20, 20, 0, 0); 
SELECT * FROM Student;

tid	name	subj1	subj2	subj3	total	per
100	ABCDE	20	20	20	60	36

REFERENCES

SOLID Principles Of Programming

Shubham Kumar Gupta — Mon, 20 Feb 2023 05:12:24 +0000

SOLID Principles Of Programming

SOLID is a set of five design principles that help us to write maintainable and flexible code.
They are, SRP (Single Responsibility Principle)
OCP (Open-Closed Principle)
LSP (Liskov Substitution Principle)
ISP (Interface Segregation Principle)
DIP (Dependency Inversion Principle)

1. SRP (Single Responsibility Principle)

A class should have only a single responsibility.
Due to this, it should also have only a single reason to change.

An example of a class that violates SRP:

class User:

    def __init__(self, name, email, password):
        self.name = name
        self.email = email
        self.password = password

    def login(self):
        pass

In the above example, the class User is responsible for both managing user data and implementing login.
We can make it adhere to SRP by making separate classes for user data and login.

class UserData:

    def __init__(self, name, email, password):
        self.name = name
        self.email = email
        self.password = password

class UserManager:

    def login(self, user_data):
        pass

2. OCP (Open-Closed Principle)

A class should be open for extension and closed for modification.
That is, we should be able to add new functionality without modifying existing code.

An example of a class that violates OCP:

class Shape:

    def __init__(self, shape_type, dimensions):
        self.shape_type = shape_type
        self.dimensions = dimensions

    def area(self):
        if self.shape_type == 'rectangle':
            pass
        elif self.shape_type == 'circle':
            pass

In the above example, we will have to modify the existing code if we need to add a new shape.
We can make it adhere to OCP by making abstract classes and methods.

from abc import ABC, abstractmethod

class Shape(ABC):

    def __init__(self, shape_type, dimensions):
        self.dimensions = dimensions

    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):

    def area(self):
        pass

class Circle(Shape):

    def area(self):
        pass

class Triangle(Shape):

    def area(self):
        pass

3. LSP (Liskov Substitution Principle)

A child class should be able to substitute its parent class.
That is, any code that works on the parent class should also work on the child class.

An example of a class that violates LSP:

class Animal:

    def __init__(self, name):
        self.name = name

    def eat(self):
        pass

class Bird(Animal):

    def fly(self):
        pass

class Ostrich(Bird):

    def fly(self):
        raise NotImplementedError

In the above example, Ostrich is a child class of Bird class but it raises an error when the fly method is called.
We can fix this method by making Ostrich a child class of Animal instead of Bird.

class Animal:

    def __init__(self, name):
        self.name = name

    def eat(self):
        pass

class Bird(Animal):

    def fly(self):
        pass

class Ostrich(Animal):
    pass

4. ISP (Interface Segregation Principle)

A client should not be forced to depend on methods it does not use.
That is, we should keep our interfaces small and focus only on functionality that the client needs.

An example of a class that violates ISP:

class Document:

    def __init__(self, text):
        self.text = text

    def print(self):
        pass

    def fax(self):
        pass

    def scan(self):
        pass

In the above example, if a client only needs to print the document, they will still be forced to use the fax and scan method.
We can make it adhere to ISP by splitting the Document class into smaller, more focused classes.

class Printable:

    def print(self):
        pass

class Faxable:

    def fax(self):
        pass

class Scanable:

    def scan(self):
        pass

class Document:

    def __init__(self, text):
        self.text = text

class Printer(Document, Printable):
    pass

class Fax(Document, Faxable):
    pass

class Scanner(Document, Scanable):
    pass

5. DIP (Dependency Inversion Principle)

Higher-level modules should not depend upon lower-level modules.
Instead both should depend on abstractions.

An example of a class that violates DIP:

class Database:

    def insert(self, data):
        pass

class User:

    def __init__(self, name, database):
        self.name = name
        self.database = database

    def save(self):
        pass

In the above example, the class user is dependent on the class Database.
To make it adhere to DIP, we can create an abstraction for the Database.

from abc import ABC, abstractmethod

class DatabaseInterface(ABC):

    @abstractmethod
    def insert(self, data):
        pass

class Database(DatabaseInterface):

    def insert(self, data):
        pass

class User:

    def __init__(self, name, database):
        self.name = name
        self.database = database

    def save(self):
        pass

REFERENCES

OOP In Python

Shubham Kumar Gupta — Wed, 15 Feb 2023 12:17:07 +0000

OOP In Python

OOP (Object Oriented Programming) in Python allows us to use objects to represent entities.
Each object has its own attributes and methods derived from the Class it belongs to.
Some examples of pre-existing classes in Python are Integer, Strings, Lists, Sets, Dictionary, etc.
Whenever we are creating, for example, a new list in Python, we are actually creating an object of class List.
The new list created has all the methods that are defined in List Class, for example, append, insert, sort, etc.
We can create our own classes and objects in Python to build real-life applications
Using OOPS allows us to organize, maintain and scale our code more efficiently.
The four main pillars of OOP are Encapsulation, Inheritance, Abstraction, and Polymorphism.

Class and Objects

An object is to represent an entity belonging to a particular Class.
A class is a blueprint for creating objects in OOP.
Classes have their own attributes and methods(functions) that can be accessed by objects belonging to that class.
We can initialize the attributes of Class using init method (constructor).

class Dog:                          # class naming with PascalCase
    # constructor
    def __init__(self, name, age):
        self.name = name            # creating class attributes
        self.age = age

    def speak(self):                # creating class methods
        return f'My name is {self.name}, and I am {self.age} years old.'

bruno = Dog("Bruno", 9)             # creating object

print(bruno.name)                   # accessing Class attribute from object
print(bruno.age)

print(bruno.speak())                # accessing Class method from object

Output:

Bruno
9
My name is Bruno, and I am 9 years old.

1. Encapsulation:

Encapsulation allows us to hide the object's attributes and method from outside access.
Python doesn't have encapsulation in the same sense as other OOP languages.
Python doesn't have truly private or protected attributes and methods.
Attributes and methods that are meant to be protected are prefixed with a single underscore: _
However, they can still be accessed and modified using their names.
Attributes and methods that are meant to be private are prefixed with a double underscore: __
However, they can still be accessed and modified using name mangling.
Also, both can still be accessed and modified using get and set methods.

class Dog:

    def __init__(self, name, age):
        self.__name = name      # private attribute
        self._age = age         # protected attribute

    def get_name(self):         # get method
        return self.__name

    def set_name(self, name):   # set method
        self.__name = name

    def get_age(self):          # get method
        return self._age

    def set_age(self, age):     # set method
        self._age = age

    def __show(self):           # private method
        return f"My name is {self.__name} and I am {self._age} years old."

    def _speak(self):           # protected method
        return "WOOF!"

bruno = Dog("Bruno", 9)

bruno._Dog__name = "Shero"  # modifying private attribute using name mangling
print(bruno._Dog__name)     # accessing private attribute using name mangling

bruno.set_name("Cheems")    # modifying private attribute using set method
print(bruno.get_name())     # accessing private attribute using get method

bruno._age = 6              # modifying protected attribute using its name
print(bruno._age)           # accessing protected attribute using its name

bruno.set_age(3)            # modifying protected attribute using set method
print(bruno.get_age())      # accessing protected attribute using get method

print(bruno._Dog__show())   # accessing private method using name mangling
print(bruno._speak())       # accessing protected method using it's name

Output:

Shero
Cheems
6
3
My name is Cheems and I am 3 years old.
WOOF!

2. Inheritance

Inheritance allows us to create a new class (called 'child class') based on another class (called 'parent class').
The child class inherits all the attributes and methods of the parent class.
In addition, the child class it's own unique attributes and methods.
There are several types of inheritance namely, single-level, multi-level, multiple, hierarchical, and hybrid.

class Pet:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print(f'My name is {self.name}, and I am {self.age} years old.')

class Cat(Pet):                     # inheriting parent class in child class

    def speak(self):                # accessing parent class attribute in child class by default
        print("Meow!")

class Dog(Pet):                     # inheriting parent class in child class

    def __init__(self, name, age, sport):
        super().__init__(name, age)     # accessing parent class attribute in child class using super
        self.sport = sport              # child class accessing its own attributes

    def speak(self):
        print(f'My favorite sport is {self.sport}.')

D = Dog("Bruno", 9, 'Football')
C = Cat("Missa", 6)

D.show()                        # accessing parent class method in child class
D.speak()                       # child class accessing its own attributes

C.show()                        # accessing parent class method in child class
C.speak()                       # child class accessing its own attributes

Output:

My name is Bruno, and I am 9 years old.
My favorite sport is Football.
My name is Missa, and I am 6 years old.
Meow!

3. Abstraction

Abstraction allows us to hide classes and methods not necessary for the user.
We can make an abstract class in python by setting the parent class of any class to ABC after importing it from abc (Abstract Class Bases).
After that, we can create an abstract method using the @abstractmethod decorator.
We can still access the non-abstract method of abstract classes.

from abc import ABC, abstractmethod

class PET(ABC):         # create an abstract class
    @abstractmethod     # create an abstract method
    def speak(self):
        pass

    def show(self):
        print("I am a Pet.")

class Dog(PET):

    def speak(self):
        print("WOOF!")

class Cat(PET):

    def speak(self):
        print("Meow!")

bruno = Dog()           
bruno.speak()           # ignoring abstract method of abstract class
bruno.show()            # non-abstract method of the abstract class still works

missa = Cat()           
missa.speak()           # ignoring abstract method of abstract class
missa.show()            # non-abstract method of the abstract class still works

nemo = PET()            # will throw an error because we cannot instantiate an abstract class.

Output:

WOOF!
I am a Pet.
Meow!
I am a Pet.
Can't instantiate abstract class PET with abstract method speak

4. Polymorphism

Polymorphism allows an object to take on many forms.
Polymorphism in Python can be achieved in two ways: method over-riding and duck-typing.

A. Method Over-riding

Method overriding allows a child class to have a different definition of a method already defined in the parent class.

class Pet:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print(f'My name is {self.name} and I am {self.age} years old.')

class Fish(Pet):
    pass

class Dog(Pet):

    def speak(self):                # over-riding parent's class method
        print(f'WOOF! My name is {self.name} and I am {self.age} years old.')

nemo = Fish("Nemo", 2)
bruno = Dog("Bruno", 9)

nemo.speak()                        # parent's class method runs
bruno.speak()                       # child's class method runs

Output:

My name is Nemo and I am 2 years old.
WOOF! My name is Bruno and I am 9 years old.

B. Duck Typing

Duck Typing allows different types of classes to have the same method name with its own definition.

class Fish:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):                # method of first class
        print(f'My name is {self.name} and I am {self.age} years old.')

class Dog:

    def __init__(self, name, age, breed):
        self.name = name
        self.age = age
        self.breed = breed

    def speak(self):                # method of second class with same name
        print(f'WOOF! My name is {self.name} and I am {self.age} years old, and I am a {self.breed}.')

nemo = Fish("Nemo", 2)
bruno = Dog("Bruno", 9, "Shiba Inu")

nemo.speak()                        # method of first class runs
bruno.speak()                       # method of the second class with the same name runs

Output:

My name is Nemo and I am 2 years old.
WOOF! My name is Bruno and I am 9 years old, and I am a Shiba Inu.

Dunder/Magic Methods:

Dunder or magic methods are special methods used in Python classes.
They are used to define how objects of classes behave in case they are used with in-built Python operations.
Some commonly used dunder methods are init(self,...), str(self), repr(self), len(self), ads(self), del(self), etc.
Dunder methods cannot be called, they run automatically when called by in-built python functions.

class SimpleClass:

    # constructor
    def __init__(self, value1, value2):
        self.value1 = value1
        self.value2 = value2

    # string representation of the object
    def __str__(self):
        return f'value 1 is {self.value1} and value 2 is {self.value2}.'

    # string representation for debugging purposes
    def __repr__(self):
        return f'This is an object of the class SimpleClass'

    # returns output when len() function is called
    def __len__(self):
        return 1

    # returns the sum when + operator is called between two objects.
    def __add__(self, other):
        return (self.value1 + other.value1, self.value2 + other.value2)

    def __del__(self):
        print("object deleted")

a = SimpleClass(5, 10)      # __init__ is called
b = SimpleClass(7, 9)       # __init__ is called

print(a)                    # __str__ is called
print(repr(a))              # __repr__ is called
print(len(a))               # __len__ is called
print(a + b)                # __add_ is called

Output:

value 1 is 5 and value 2 is 10.
This is an object of the class SimpleClass
1
(12, 19)

REFERENCES

String Methods in Python

Shubham Kumar Gupta — Wed, 15 Feb 2023 06:51:53 +0000

String Methods in Python

1. upper():

Returns a copy of string in upper-case.

syntax: str.upper()

string = 'My name is Shubham.'

print(string.upper())

output: MY NAME IS SHUBHAM.

2. lower():

Returns a copy of string in lower-case.

syntax: str.lower()

string = 'My name is Shubham.'

print(string.lower())

output: 'my name is shubham.'

3. swapcase()

Returns a copy of string in swapped-case.

syntax: str.swapcase()

string = 'My name is Shubham.'

ptint(string.swapcase())

output: 'mY NAME IS sHUBHAM.'

4. capitalize()

Returns a copy of string with first letter in upper-case and rest in lower-case.

syntax: str.capitalize()

string = 'My name is Shubham.'

print(string.capitalize())

output: My name is shubham.

5. title()

Returns a copy of string in title-case.

syntax: str.title()

string = 'My name is Shubham.'

print(string.title())

output: My Name Is Shubham.

6. isupper()

Returns boolean value if all the letters in string are upper-case.

syntax: str.isupper()

string1 = 'MY NAME IS SHUBHAM.'
string2 = 'My name is Shubham.'

print(string1.isupper())
print(string2.isupper())

output: True, False

7. islower()

Returns boolean value if all the letters in string are lower-case.

syntax: strislower()

string1 = 'my name is shubham.'
string2 = 'My name is Shubham.'

print(string1.islower())
print(string2.islower())

output: True, False

8. isalnum():

Returns boolean value if all the characters in the string are alpha-numeric.

syntax: str.isalnum()

string1 = 'My1name2is3Shubham4'
string2 = 'My name is Shubham.'

print(string1.isalnum())
print(string2.isalnum())

output: True, False

9. isalpha():

Returns boolean value if all the characters in the string are alphabet.

syntax: str.isalpha()

string1 = 'MyNameIsShubham'
string2 = 'My name is Shubham.'

print(string1.isalnum())
print(string2.isalnum())

output: True, False

10. isdigit():

Returns boolean value if all the characters in the string are digit.

syntax: str.isdigit()

string1 = '1234'
string2 = 'My name is Shubham.'

print(string1.isdigit())
print(string2.isdigit())

output: True, False

11. startswith(str):

Returns boolean if the string starts with given sub-string.

syntax: str.startswith(sub_string)

string = 'My name is Shubham.'

print(string.startswith('My'))
print(string.startswith('Shubham.'))

output: True, False

12. endswith(str):

Returns boolean if the string ends with given sub-string.

syntax: str.endswith(sub_string)

string = 'My name is Shubham.'

print(string.endswith('Shubham.'))
print(string.endswith('My'))

output: True, False

13. count(str):

Returns the count of the number of times a substring appears in the string.

syntax: str.count(sub_str)

string = 'My name is Shubham and my favorite coding language is Python.'

print(string.count('is'))

output: 2

14. find(str):

Returns the index of first occurance of given substring in string. Return -1 if given substring is not present in string.

syntax: str.found(sub_str)

string = 'My name is Shubham.'

print(string.find('name'))
print(string.find('years'))

output: 3, -1

15. replace(str1, str2):

Returns a string replacing substring in the first parameter from the string with substring in the second parameter.

syntax: str.replace(sub_str1, sub_str2)

string = 'My name is Shubham.'

print(string.replace('My name is', 'Myself'))

output: Myself Shubham.

16. split():

Returns a list of words splitted from the given string.

syntax: str.split()

string = 'My name is Shubham.'

print(string.split())

output: ['My', 'name', 'is', 'Shubham.']

17. join(itr):

Returns a string joined from the elements of given iterable.

syntax: "*".join(iterable)

l = ['My', 'name', 'is', 'Shubham.']

print(" ".join(l))

output: My name is Shubham.

REFERENCES

Python Documentation

Array/List Methods in Python

Shubham Kumar Gupta — Wed, 15 Feb 2023 05:19:19 +0000

Array/List Methods in Python

1. append(x):

Adds an element to the end of the list

syntax: list.append(element)

l = [7, 6, 7, 5, 4, 9]

l.append(5)
print(l)

output: [7, 6, 7, 5, 4, 9, 5]

2. insert(i, x):

Insert an element at a given index.

syntax: list.insert(index, element)

l = [7, 6, 7, 5, 4, 9, 5]

l.insert(1, 3)
print(l)

output: [7, 3, 6, 7, 5, 4, 9, 5]

3. remove(x):

Removes the first occurrence of the given element.

syntax: list.remove(element)

l = [7, 3, 6, 7, 5, 4, 9, 5]

l.remove(5)
print(l)

output: [7, 3, 6, 7, 4, 9, 5]

4. pop(i):

Removes the element from the given index. If no index is given, it removes the last element from the list.

syntax: list.pop(index)

l = [7, 3, 6, 7, 4, 9, 5]

l.pop(2)
print(l)

l.pop()
print(l)

output: [7, 3, 7, 4, 9, 5], [7, 3, 7, 4, 9]

5. index(x, s, e):

Returns the list's first index of a given element. Start and end parameters are optional and specify the index to start the search from and, end to. If only one parameter other than the element is given, it defaults to start. If element is not found in the list, it returns a ValueError.

syntax: list.index(element, start (optional), end (optional))

l = [7, 3, 7, 4, 9, 7]

x = l.index(7)
print(x)

y = l.index(7, 2)
print(y)

z = l.index(7, 3, 6)
print(z)

p = l.index(5)
print(p)

output: 0 , 2 , 5 , ValueError

6. count(x):

Counts the number of times an element appears in the list

syntax: list.count(element)

l = [7, 3, 7, 4, 9]

x = l.count(7)
print(x)

output: 2

7. sort(*, key = , reverse = True/False):

Sorts the list in ascending (by-default), descending, alphabetical (by-default), reverse-alphabetical, or according to a user-given order.

syntax: list.sort(*, key = , reverse = True/False(Default))

l1 = [7, 3, 7, 4, 9]

l1.sort()
print(l1)

l1.sort(reverse = True)
print(l1)

l2 = ['bb', 'a', 'dddd', 'ccc']

l2.sort()
print(l2)

l2.sort(reverse=True)
print(l2)

l2.sort(key = len)
print(l2)

l2.sort(key = len, reverse = True)
print(l2)

output: [3, 4, 7, 7, 9], [9, 7, 7, 4, 3], ['a', 'bb', 'ccc', 'dddd'], ['dddd', 'ccc', 'bb', 'a'], ['a', 'bb', 'ccc', 'dddd'], ['dddd', 'ccc', 'bb', 'a']

8. reverse():

Reverses the elements of the given list.

syntax: list.reverse()

l = [7, 3, 7, 4, 9]

l.reverse()
print(l)

output: [9, 4, 7, 3, 7]

9. copy():

Returns a copy of the given list.

syntax: list2 = list1.copy()

l1 = [9, 4, 7, 3, 7]

l2 = l1.copy()
print(l1)

output: [9, 4, 7, 3, 7]

10. extend(list):

Adds elements of the second list to the end of the first list.

syntax: list1.extend(list2)

l1 = [9, 4, 7, 3, 7]
l2 = ['bb', 'a', 'dddd', 'ccc']

l1.extend(l2)
print(l1)

output: [9, 4, 7, 3, 7, 'bb', 'a', 'dddd', 'ccc']

11. clear():

Removes all the elements of the given list.

syntax: list.clear()

l1 = [9, 4, 7, 3, 7, 'bb', 'a', 'dddd', 'ccc']

l1.clear()
print(l1)

output: []

REFERENCES

Python Documentation

Bash Variables

Shubham Kumar Gupta — Thu, 02 Feb 2023 04:22:59 +0000

Bash Variables

In the bash shell, variables are used to store values. Variables can be declared and assigned values using the following syntax:

variable_name=value

For example:

name="Shubham Kumar Gupta"

To reference the value stored in a variable, prefix the variable name with a '$' symbol.

echo "My name is $name"

In bash, variables can store string, integer or floating-point values.
Variable names are case-sensitive.
Varibale names can only contain letters, numbers, and underscores and they must start with a letter or an underscore.

How to change $PATH variable

The $PATH variable in bash defines the search path for executables.
We can change it by modifying the contents of the $PATH environment variable.

Few ways to modify the $PATH variable in bash:

Temporarily modify $PATH for the current shell session:

PATH="$PATH:/new/directory"

Permanently modify $PATH for the current user:

echo 'export PATH="$PATH:/new/directory"' >> ~/.bashrc

Permanently modify $PATH for the system-wide shell:

echo 'export PATH="$PATH:/new/directory"' >> /etc/environment

In each of the above examples, replace /new/directory with the path to the directory you want to add to the $PATH variable.
After modifying the $PATH variable, you may need to log out and log back in or restart your terminal session for the changes to take effect.