DEV Community: NK1FC

Django Concepts

NK1FC — Tue, 04 Apr 2023 10:46:43 +0000

1. Settings file

What is secret key?

Django uses a secret key as a string to ensure secure cryptographic signing and encryption of sensitive data such as cookies and session information. It is crucial to keep the key confidential and not reveal it to the public.

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

Django has a set of built-in apps that include admin, auth, contenttypes, sessions, and messages. These apps offer a range of essential features such as user authentication, session management, content types, messaging, and administration interface.

Apart from these, there are various other official Django apps that can be utilized, such as caching, file storage, database routing, form handling, and so on. Furthermore, there are numerous third-party Django apps available that can be installed and integrated to enhance the capabilities of a Django project.

What is middleware? What are different kinds of middleware?

Middleware is a feature in Django that allows you to change the requests and responses between the web server and your application. There are different types of middleware that can be used for different purposes. Some middleware can modify incoming requests, some can modify the response generated by the view function, some can handle exceptions that occur during processing, and some can modify the response after it has been generated. Middleware is a way to change the behavior of your application without modifying its core functionality.

Different Kind of middleware

Process Request Middleware: modifies incoming requests before they are passed to view functions.
View Middleware: modifies the response generated by the view function before it is returned to the user.
Process Exception Middleware: handles exceptions that occur during the processing of a request.
Process Response Middleware: modifies the response after it has been generated by the view function but before it is returned to the user.

Django Security

Django offers various security features to assist developers in creating secure web applications. These features include protection against cross-site scripting (XSS) attacks by automatically escaping user input, prevention against cross-site request forgery (CSRF) attacks using CSRF tokens, safeguarding against SQL injection attacks through ORM, prevention of clickjacking attacks using X-Frame-Options header, password hashing using the PBKDF2 algorithm, session management for preventing session hijacking, and support for HTTPS connections.

CSRF

A CSRF attack happens when a hacker tricks a person into doing something on a different website where they are already signed in. The bad website sends a harmful request to the real website using the person's already-signed-in account. This allows the attacker to take actions using the person's account without their knowledge. To stop CSRF attacks, developers can use techniques such as adding special tokens to forms or making the person confirm before doing important actions.

XSS

XSS is a type of web attack where hackers can put harmful code into a website that other people visit. This code can then be used to steal sensitive information, like passwords, or to do things without the user knowing. To stop XSS attacks, developers can make sure any input from users is cleaned up and made safe, and use special tools to stop the harmful code from working. Using tools like Django can also help protect against XSS attacks.

Clickjacking

Clickjacking is a type of online attack where a harmful website tricks a user into clicking on a hidden or camouflaged link or button on a different website where the user is already logged in. This is done by overlapping an unseen or partly visible element, such as a button or link, on top of a genuine website, causing the user to unintentionally click on the hidden element. Techniques like frame-busting scripts or configuring the X-Frame-Options header can help prevent clickjacking attacks.

What is WSGI?

WSGI is an interface between web servers and Python-based web applications or frameworks that enables the development of web applications in Python that can run on any WSGI-compatible web server. This interface specification provides flexibility and portability for web applications.

2. Models file

What is ondelete Cascade?

When defining a ForeignKey field in Django, the on_delete parameter specifies the action to be taken when the referenced object is deleted. on_delete has different options like CASCADE, PROTECT, SET_NULL, SET_DEFAULT, SET(), and DO_NOTHING. CASCADE is one of the options that instructs Django to delete all objects that have a foreign key pointing to the deleted object. This is useful for maintaining data consistency in database relationships.

Fields and Validators

Fields in Django refer to the data types that define the structure of a database table. Validators, on the other hand, are functions that validate the data entered into those fields. For instance, CharField can be used as a field to store character strings, and a validator can be used to check that the input data meets certain requirements such as minimum or maximum length. Validators can also verify specific patterns or formats, such as email address or phone number. By utilizing fields and validators, Django ensures robust data management and validation in web applications.

3. Django ORM

Using ORM queries in Django Shell

To use ORM queries in the Django shell, you must first open it by running the command "python manage.py shell" in the terminal. Once it's open, import relevant models from the Django project using the "from app_name.models import ModelName" syntax. Then, use the models to perform ORM queries like creating new objects with the ".create()" method, retrieving objects with the ".get()" or ".filter()" methods, or updating objects with the ".save()" method.

The Django shell is a useful tool for developers to test and refine their database interactions in a controlled environment.

Turning ORM to SQL in Django Shell

To view the SQL query that will be executed for a Django ORM query in the shell, you can access the "query" attribute of the query. For example, if you have a QuerySet called "products", you can print the corresponding SQL query by calling "print(products.query)". This allows you to see the actual SQL code that will be sent to the database, which can be helpful for debugging or optimization purposes.

What are Aggregations?

Aggregations in Django are a collection of functions that allow for calculations to be performed on a QuerySet to obtain aggregated or summarized results. To use aggregations, the .aggregate() method is used to group related items and perform calculations on them, such as counting or averaging.

What are Annotations?

Annotations in Django refer to the mechanism of adding computed fields to a QuerySet. It involves using aggregate functions like Sum, Count, Avg, etc., to calculate results based on related fields and adding them as new fields in the QuerySet. This provides a way to include dynamic or computed fields that can be used for filtering or sorting the QuerySet without modifying the database schema. Annotations can be added to a QuerySet using the .annotate() method and one or more annotation expressions.

What is a migration file? Why is it needed?

A migration file is a Python script that contains instructions for modifying the database schema whenever you make changes to your models, such as adding or removing fields. The purpose of migration files is to version control changes to the database schema and ensure consistency among developers working on the project. Migration files also enable updating the database schema without data loss by applying the changes defined in the migration files when migrations are run. In summary, migration files are a crucial component of Django's database migration system, facilitating the management of database schema changes in a controlled and reproducible manner.

What are SQL transactions?

SQL transactions are a way to group multiple SQL statements into a single, atomic unit of work that can either be completed in its entirety or rolled back if an error occurs.

What are atomic transactions?

Atomic transactions refer to a database management concept where a transaction is treated as an indivisible unit of work. It guarantees that either all the actions in the transaction will be successfully completed, or none of them will be applied to the database. The purpose of atomicity is to ensure the consistency of the database, even if there are errors or interruptions during the transaction.

HTML-CSS Concepts

NK1FC — Thu, 02 Mar 2023 05:54:34 +0000

BOX MODEL

The CSS box model refers to a rectangular box that is created around the html element.
It consists of four parts: content, padding, border, and margin.
- Content: It represent content inside the element.
- Padding: it represent the space between the content and the border.
- Border: Line that surrounds the padding.
- Margin: The space between the border and adjacent HTML elements.
To change the padding arround the content use padding-left, padding-right, padding-top, and padding-bottom.
To change the border around the padding use border-left, border-right, border-top, and border-bottom.
Similarly, to change the margin use margin-left, margin-right, margin-top, and margin-bottom.

INLINE VS BLOCK ELEMENTS

1. BLOCK ELEMENTS

Block elements take up the entire width of their container.
They create a line break after the element.
Some of the examples of block elements are <div>, <h1>-<h6>, <p>, <ul>, <ol>, <li>, <table>, <form>, and <footer>.
It is used to create structure of webpage.

2. INLINE ELEMENTS

Inline elements take up only neccessay width.
They can't create a line break after the element.
Some of the examples of inline elements are <span>, <a>, <strong>, <em>, <img>, and <input>.

CSS POSITIONING

1. Relative POSITIONING

The element is positioned according to the normal flow of the document, and then offset relative to itself based on the values of top, right, bottom, and left.

2. ABSOLUTE POSITIONING

This element is removed from the normal document flow, and no space is created for the element in the page layout. It is positioned relative to its closest positioned ancestor

COMMON CSS STRUCTURAL CLASSES

.row: This class is used to create a row of columns in a grid-based layout.
.col: This class is used to create columns in a grid-based layout.
.container: This class is used to create a container for the web page content, often used to center and set a maximum width for the content area.
.wrapper: This class is used to wrap the main content of the web page. It's often used to create a container for the content that's separate from the header and footer.
.rightmenu: This class is used to style a right sidebar section on webpage.
.main-content: This class is used to style the main content section of a web page.
.leftmenu : This class is used to style a left sidebar section on webpage.

COMMON CSS STYLING CLASSES

.container: This class is used to create a container that holds the content of a web page or sometimes container which will hold other elements.
.header: This class is used to style the header section of a web page, which typically contains the site logo, navigation menu, and other important information.
.nav: This class is used to style navigation menus on a web page, such as a top or side menu.
.btn: This class is used to style buttons on a web page. It's often used to add a background color, border, and padding to create a clickable button.
.card: This class is used to create a card-style layout for content, such as a blog post or product listing. It often includes a background color, border, and padding to create a contained section for the content.
.footer: This class is used to style the footer section of a web page, which typically contains copyright information, social media links.

CSS SPECIFICITY

CSS specificity is a method to determine which style to apply if there is any conflict.
Types of selectors in CSS with their specificity value:
- Type selectors and pseudo-elements - they have the lowest specificity value (0,0,0,1)
- Class selectors, attributes selectors and pseudo-classes - they have a medium specificity value (0,0,1,0)
- ID selectors - they have a high specificity value (0,1,0,0)
- Inline styles - they have the highest specificity value (1,0,0,0)
When two or more styles are applied to an element, the style with the highest specificity value will apply.
If two selectors have the same specificity value, the one that was defined last in the CSS file will apply to the element.

CSS RESPONSIVE QUERIES

CSS responsive queries are also called media queries.
They allow developer to apply CSS styles on webpage based on the viewport of the device or browser in device.
Syntax start with @media rule.
We use differrent queries to target specific device sizes, such as smartphones or tablets, using min-width and max-width.
- @media all and (max-width: 767px): Commonly used for smartphones.
- @media all and (min-width: 768px) and (max-width: 1023px): Commonly used for tablets.
- @media all 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).
- To align items vertically set the flex-direction: column, then the main-axis will be vertical and cross-axis will be Horizontal.
- To align items Horizontally set the flex-direction: row, then the main-axis will be horizontal and cross-axis will be vertical.
Justify-content works on main axis.
align-items work on cross axis.
gap is used to provide space between the element of main axis and cross axis.

2. GRID

Two-dimensional layout system.
Creates a grid of rows and columns.
Allows placement of elements within the grid.
grid-template-columns/grid-template-rows - It defines the size and number of column/row in grid.
grid-column- In this we need to specift the positon of starting of column and ending of column upto which content needed to spread.
grid-row- In this we need to specift the positon of starting of row and end of row upto which content needed to spread.
grid-gap Defines the gap between grid cells.
justify-items- Aligns object along the horizontal axis.
align-items- Aligns object along the vertical axis.

COMMON HEADER META TAGS

<title>: Defines the title of webpage.
<meta charset="utf-8">: Specifies the character encoding used in the webpage.
<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 small description of the webpage.
<link rel="stylesheet" href="stylesheet.css">: Use this to link external css file to the html file.

CSS UNITS

ABSOLUTE UNITS

This unit is depended on parent element. For example, setting the font size of a parent element to 16px and the font size of a child element to 1.5em would result in a font size of 24px for the child element.

rem

This unit is depend on root element. For example, setting the font size of a root element to 16px and the font size of a element to 1.5rem would result in a font size of 24px for that element.

This unit is the percentage of its parent element. For example, setting the font size of a parent element to 16px and the font size of a child element to 50% would result in a font size of 8px for the child element.

vw/vh

This unit is depend upon the height and width of viewport. For example, setting the height of an element to 50vh would make it half the height of the viewport.

RELATIVE UNITS

It represent the physical pixel of the screen.

in/cm/mm

This is physical units such as centimeter,inch and milimeter.

REFERENCES

Geek For Geeks. "CSS units – %, em, rem, px, vh, vw". Retrieved from https://www.geeksforgeeks.org/css-units-em-rem-px-vh-vw/
Java T Point. "CSS Box Model". Retrieved from https://www.javatpoint.com/css-box-model
MDN web docs. "position". Retrieved from https://developer.mozilla.org/en-US/docs/Web/CSS/position
W3 School. "HTML Block and Inline Elements". Retrieved from https://www.w3schools.com/html/html_blocks.asp
Geek For Geeks. "CSS Grid Layout Module". Retrieved from https://www.geeksforgeeks.org/css-grid-layout-module/
W3 School. "CSS Flexbox". Retrieved from https://www.w3schools.com/css/css3_flexbox.asp

Revision - 28/02/2023

NK1FC — Tue, 28 Feb 2023 07:24:22 +0000

1. What is the git command to add and commit files at the same time?

The command used to git add and commit files at the same time is

git commit -am 'Message'

This command will only work with tracked files if a new file is created then firstly perform git add filename, Now any changes applied to the file can be committed using git commit -am 'Message'.

2. How to find a file with a particular set of permissions using CLI?

To find a file with a particular set of permissions use the command

find /path/to/search/file -prem 777

3. What is the lambda function in Python?

A lambda function is a small anonymous function that can take any number of arguments but only have one expression.
Syntax:

lambda arguments : expression

Example:

x = lambda a : a * 10
print(x(5))
#output- 50

4. We can store binary objects and images in a database. What will be the data type used for storing these types of files using PostgreSQL?

The data type used to store multimedia objects in a database is BLOB(Binary Large Object), It is commonly used where large files need to be stored in a database.

5. What is dense rank and rank in SQL?

RANK skips the number of positions after records with the same rank number. The ranking DENSE_RANK returns position numbers from 1 to 6 because it doesn’t skip records with the same rank number.

An example of RANK is:

An example of DENSE_RANK is:

6. In flexbox, what is the difference between justify-contents and align-items?

justify-content — controls alignment of all items on the main axis.

align-items — controls alignment of all items on the cross-axis.

7. What is the difference between a list and a tuple with respect to mutability in Python?

Lists are mutable, which means that you can add, remove, or modify elements in a list after it has been created. Tuples are immutable, which means that once a tuple has been created, its elements cannot be changed.

8. What is the difference between primitive and non-primitive data types?

The primitive data structure is a fundamental type of data structure that stores the data of only one type. Examples of primitive data structures are integer, character, and float.

The non-primitive data structure is a type of data structure that is user-defined and stores the data of different types in a single entity. Examples of the non-primitive data structure are Array, Linked list, and stack.

9. Why is it important to understand SQL query execution order?

Avoiding errors:
- Misplacing WHERE clause.
- Incorrect use of aggregate functions such as SUM, COUNT, and AVG if you use it with the wrong grouping it may result in the wrong answer.
Performance tuning:
- Using indexing to improve the speed of queries.
- Optimization: you can use the WHERE clause to filter out unwanted rows before performing expensive JOIN.

10. What is a box model in HTML? How to assign padding using short-hand format and is it applicable to the margin as well?

The CSS box model refers to a rectangular box that is created around the HTML element.
It consists of four parts: content, padding, border, and margin.
- Content: It represents content inside the element.
- Padding: represents the space between the content and the border.
- Border: Line that surrounds the padding.
- Margin: The space between the border and adjacent HTML elements.

*{
padding: 2px 5px 7px 10px;
/*
    top padding is 2px
    right padding is 5px
    bottom padding is 7px
    left padding is 10px
*/
padding: 2px 5px 7px;
/*
    top padding is 2px
    right and left paddings are 5px
    bottom padding is 7px
*/
padding: 2px 5px;
/*
    top and bottom paddings are 2px
    right and left paddings are 5px
*/

 padding: 2px;
/*
all four paddings are 2px
*/
}

It is also applicable for margin property.

SQL Concepts

NK1FC — Wed, 22 Feb 2023 05:25:16 +0000

SQL Concepts

ACID

ACID stands for:
- A-Atomicity
- C-Consistency
- I-Isolation
- D - Durability

Atomicity

It refers to All changes to data being performed as if they are a single operation.
Either all the changes will take place or none.
Example- If you try to do some transaction there is some error the transaction will be canceled no change will take place.

Consistency

Data remain the same at the start of the operation and the end of the operation.

Isolation

Multiple transactions can be operated without interfering with each other.

Durability

The changes to the database will occur after transaction completion even if there is a system failure.

CAP theorem

It states that in a distributed computing system, it is impossible to simultaneously provide more than two out of three guarantees: Consistency, Availability, and Partition Tolerance.

Joins

SQL Join statement is used to combine two or more tables.

Different types of Joins are as follows:


/*
Table 1
+------------+------+-------+
| student_id | name | class |
+------------+------+-------+
| 1          | nik  | 4     |
+------------+------+-------+
| 2          | sik  | 7     |
+------------+------+-------+
| 3          | dk   | 9     |
+------------+------+-------+
*/

/*
Table 2
+------------+-------+
| student_id | score |
+------------+-------+
| 1          | 5     |
+------------+-------+
| 2          | 4     |
+------------+-------+
| 4          | 6     |
+------------+-------+
*/

1.INNER JOIN :
It joins all the relevant data in tables.

Syntax

/*
Table 1
+------------+------+-------+
| student_id | name | class |
+------------+------+-------+
| 1          | nik  | 4     |
+------------+------+-------+
| 2          | sik  | 7     |
+------------+------+-------+
| 3          | dk   | 9     |
+------------+------+-------+
*/

/*
Table 2
+------------+-------+
| student_id | score |
+------------+-------+
| 1          | 5     |
+------------+-------+
| 2          | 4     |
+------------+-------+
| 4          | 6     |
+------------+-------+
*/
SELECT table1.student_id,table1.name,table2.score
FROM table1 
INNER JOIN table2
ON table1.student_id = table2.student_id;

/*
Output-
+------------+------+-------+
| student_id | name | score |
+------------+------+-------+
| 1          | nik  | 5     |
+------------+------+-------+
| 2          | sik  | 4     |
+------------+------+-------+
*/

2.LEFT JOIN :

It returns all the rows of the table on the left side of the join and Returns all the matching values on that row if not present then null.

Syntax

/*
Table 1
+------------+------+-------+
| student_id | name | class |
+------------+------+-------+
| 1          | nik  | 4     |
+------------+------+-------+
| 2          | sik  | 7     |
+------------+------+-------+
| 3          | dk   | 9     |
+------------+------+-------+
*/

/*
Table 2
+------------+-------+
| student_id | score |
+------------+-------+
| 1          | 5     |
+------------+-------+
| 2          | 4     |
+------------+-------+
| 4          | 6     |
+------------+-------+
*/
SELECT table1.student_id,table1.name,table2.score
FROM table1 
LEFT JOIN table2
ON table1.student_id = table2.student_id;

/*
Output-
+------------+------+-------+
| student_id | name | score |
+------------+------+-------+
| 1          | nik  | 5     |
+------------+------+-------+
| 2          | sik  | 4     |
+------------+------+-------+
| 3          | dk   | Null  |
+------------+------+-------+
/*

3.RIGHT JOIN :

It returns all the rows of the table on the right side of the join and Returns all the matching values on that left if not present then null.

Syntax

/*
Table 1
+------------+------+-------+
| student_id | name | class |
+------------+------+-------+
| 1          | nik  | 4     |
+------------+------+-------+
| 2          | sik  | 7     |
+------------+------+-------+
| 3          | dk   | 9     |
+------------+------+-------+
*/

/*
Table 2
+------------+-------+
| student_id | score |
+------------+-------+
| 1          | 5     |
+------------+-------+
| 2          | 4     |
+------------+-------+
| 4          | 6     |
+------------+-------+
*/
SELECT table1.student_id,table1.name,table2.score
FROM table1 
RIGHT JOIN table2
ON table1.student_id = table2.student_id;

/*
Output-
+------------+------+-------+
| student_id | name | score |
+------------+------+-------+
| 1          | nik  | 5     |
+------------+------+-------+
| 2          | sik  | 4     |
+------------+------+-------+
| 4          | Null | 6     |
+------------+------+-------+
/*

4.FULL JOIN :

It joins the table and will contain all the rows which also include null values of right join and left join.

Syntax

/*
Table 1
+------------+------+-------+
| student_id | name | class |
+------------+------+-------+
| 1          | nik  | 4     |
+------------+------+-------+
| 2          | sik  | 7     |
+------------+------+-------+
| 3          | dk   | 9     |
+------------+------+-------+
*/

/*
Table 2
+------------+-------+
| student_id | score |
+------------+-------+
| 1          | 5     |
+------------+-------+
| 2          | 4     |
+------------+-------+
| 4          | 6     |
+------------+-------+
*/
SELECT table1.student_id,table1.name,table2.score
FROM table1 
FULL JOIN table2
ON table1.student_id = table2.student_id;

/*
Output-
+------------+------+-------+
| student_id | name | score |
+------------+------+-------+
| 1          | nik  | 5     |
+------------+------+-------+
| 2          | sik  | 4     |
+------------+------+-------+
| 3          | dk   | Null  |
+------------+------+-------+
| 4          | Null | 6     |
+------------+------+-------+
/*

Aggregations, Filters in queries

It performs a calculation on multiple columns and returns a single value.
SQL provides many aggregate functions such as avg, count, sum, min, max, etc.

Functions:

1. count()

It returns the total number of rows from a database table that matches the criteria in the SQL query.

Syntax

count(column_name)

Example

select count(*) from student;

/* 
It will return count of rows present in student table
*/

2. sum()

It adds up all the values of a particular column.

Syntax

sum(column_name)

Example

select sum(score) from students;
/*
This will add up all the scores of students in that particular column
*/

3. avg()

It will return the average value of a particular column.

Syntax

avg(column_name)

Example

select avg(score) from students;
/* 
This function will return the average of that particular table by doing sum of score then divide it by count.
*/

4. max()

It simply returns the maximum value in that particular column.

Syntax

max(column_name)

Example

select max(score) from students;
/* 
This return the max score scored by student
*/

5. min()

It simply returns the minimum value in the particular column. ### Syntax

min(column_name)

Example

select min(score) from students;
/* 
This return minimum score scored by student.
*/

6. filter()

The filter clause extends aggregate functions (sum, avg, count, …) by an additional where clause.

Syntax

SUM(column_name)
FILTER(WHERE CONDITION)

Example

select sum(score)
filter(where name like 'A%')
from students;
/* 
This will sum the score of all student whose name start with A
*/

7. group by

These statements group rows that have the same values into summary rows.
The GROUP BY statement is usually used along with aggregate functions such as count(), min(), max(), avg(), sum(), etc.

Syntax

select column_name(s)
from table_name
WHERE condition
group by column_name(s);

Example

select sum(score)
from students
group by name
/*
This will add up the score of all student with same name.
*/

8. having

These clauses add some conditions to the groupby.

Syntax

expression
group by CLAUSE
having CLAUSE
condition

Example

select sum(score)
from students
group by name
having name like 'A%'
/*
This will add up the score of all student with same name starting with A.
*/

Normalization

Normalization is organizing a database's table and its columns.
It simply means just breaking down a single table into multiple tables.
Generally used normalization types are 1NF, 2NF, and 3NF.

1. 1NF

Each column should contain only one values. For example- If a table contains two columns person and number according to 1NF it should only contain one mobile number for every person.

2. 2NF

It should follow 1NF.
The Primary key of the table should be always unique. For example- We got a table for students containing their ID and name according to 2NF the ID must be unique to each student.

3. 3NF

It should follow 2NF.
All the non-key columns must be mutually independent. For example- consider a table, the person it contains ID, name, and address to follow 3NF The table needs to break down in two tables one which contains ID and name and another table which contains ID and address.

Indexes

It improves query performance.
It reduces the time of accessing the table by creating a cache memory.

Transactions

It refers to all the properties of ACID. ## Locking mechanism
The lock mechanism is used to restrict unauthorized access.
It is used to ensure data integrity.
It is also used to ensure data consistency. Locations, where the lock can be placed, are:
- Table
- Key
- Page
- Database
- File
- Object
Different types of lock modes.
- Exclusive Lock (X)- It can hold one transaction on a resource at a particular time.
- Shared Lock (S)- It is used on pages or rows.
- Update Lock (U)- It same as an exclusive lock and it is more adaptable compared to an exclusive lock.
- Schema Lock (Sch)- It is used when an operation depends on a table.
- Bulk Update Lock (BU)- This lock is used when we need to insert a large amount of data in the database.

Database Isolation Levels

It defines the degrees to which we need to isolate the data.
The SQL standard defines four isolation levels- Read Uncommitted, Read Committed, Repeatable Read, and Serializable.

Triggers

It is a statement that executes itself when there is a particular modification to the database.
Types of triggers
- AFTER INSERT- It activates after data is inserted into the table.
- AFTER UPDATE: It activates after data in the table is modified.
- AFTER DELETE: It activates after data is deleted/removed from the table.
- BEFORE INSERT: It activates before data is inserted into the table.
- BEFORE UPDATE: It activates before data is modified in the table.
- BEFORE DELETE: It activates before data is deleted from the table.

References

Geek For Geeks. "ACID Properties in DBMS". Retrieved from https://www.geeksforgeeks.org/acid-properties-in-dbms/
Geek For Geeks. "The CAP Theorem in DBMS". Retrieved from https://www.geeksforgeeks.org/the-cap-theorem-in-dbms/
Geek For Geeks. "Aggregate functions in SQL". Retrieved from https://www.geeksforgeeks.org/aggregate-functions-in-sql/
JAVATPOINT. "Normalization". Retrieved from https://www.javatpoint.com/dbms-normalization.
JAVATPOINT. "PostgreSQL Indexes". Retrieved from https://www.javatpoint.com/postgresql-indexes
JAVATPOINT. "Transaction". Retrieved from https://www.javatpoint.com/sql-server-transaction
JAVATPOINT. "Locks in SQL Server". Retrieved from https://www.javatpoint.com/locks-in-sql-server
Geek For Geeks. "Transaction Isolation Levels in DBMS". Retrieved from https://www.geeksforgeeks.org/transaction-isolation-levels-dbms/
Geek For Geeks. "SQL | Triggers". Retrieved from https://www.geeksforgeeks.org/sql-triggers/?ref=gcse

Solid Principles in Python

NK1FC — Mon, 20 Feb 2023 07:14:21 +0000

The SOLID Principles:

The Single-Responsibility Principle (SRP)
The Open-Closed Principle (OCP)
The Liskov Substitution Principle (LSP)
The Interface Segregation Principle (ISP)
The Dependency inversion Principle (DIP)

The Single-Responsibility Principle (SRP)

This principle state that the Class should have only one responsibility.
Code That violates SRP is:

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

    def greet(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

    def celebrate_birthday(self):
        self.age += 1
        print(f"{self.name} is now {self.age} years old!")

In the above code, the Person class have two responsibility one is to greet and another one is to celebrate a birthday to follow the SRP create a different class one which handles greeting and the other handles birthday celebration.

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

    def greet(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

class BirthdayCelebrator:
    def celebrate_birthday(self, person):
        person.age += 1
        print(f"{person.name} is now {person.age} years old!")

The Open-Closed Principle (OCP)

This principle states that the class should be closed for modification but open for extension.
Code that violates OCP is:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

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

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

    def area(self):
        return 3.14 * self.radius ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate_area(self, shape):
        if isinstance(shape, Rectangle):
            return shape.area()
        elif isinstance(shape, Circle):
            return shape.area()
        elif isinstance(shape, Triangle):
            return shape.area()

In the above code if we try to create a new class such as a hexagon we need to modify the AreaCalculator class which will violate OCP.
To correct the code we just need to change the method of AreaCalculator class so there will be no need to modify AreaCalculator class.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

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

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

    def area(self):
        return 3.14 * self.radius ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = heigh.t

    def area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate_area(self, shape):
        return shape.area()

Liskov’s Substitution Principle (LSP)

This principle states that the object created using the child class can replace the object created using The parent class.
Code that violates LSP is:

class Bird:
    def fly(self):
        print("The bird is flying")

class Penguin(Bird):
    def fly(self):
        raise Exception("I can't fly")

def make_bird_fly(bird):
    bird.fly()

bird = Bird()
make_bird_fly(bird)  # Output: The bird is flying

penguin = Penguin()
make_bird_fly(penguin)  # Output: An exception is raised

In the above code, the penguin will raise the error when we call the fly method. To correct it simply do method ovveridding.

class Bird:
    def fly(self):
        print("The bird is flying")

class Penguin(Bird):
    def fly(self):
        print("I can't fly")

def make_bird_fly(bird):
    bird.fly()

bird = Bird()
make_bird_fly(bird)  # Output: The bird is flying

penguin = Penguin()
make_bird_fly(penguin) # output: I can't fly

Interface Segregation Principle (ISP)

This principle states that it is better to have many small, specific interfaces, rather than one large, general-purpose interface.
Code that violates ISP is:

from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def eat(self):
        pass
    @abstractmethod
    def sleep(self):
        pass
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def eat(self):
        print("The dog is eating")

    def sleep(self):
        print("The dog is sleeping")

    def move(self):
        print("The dog is running")

Above code violates the ISP as if we try to create a fish class using an animal class but it doesn't have ability to move so we need to create methods which are common in all animals such as eating, sleep, and reproduction.
Code that adheres ISP is:

from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def eat(self):
        pass
    @abstractmethod
    def sleep(self):
        pass
    @abstractmethod
    def reproduce(self):
        pass

above method is common in all animals hence it is the simplest interface for animals and another method will be added according to other animals in their class.

Dependency Inversion Principle (DIP)

This principle state that Entities must depend on abstractions, not on concretions. It states that the high-level module must not depend on the low-level module, but they should depend on abstractions.
Code that violates DIP is:

class Shape:
    def area(self):
        pass

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

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

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

    def area(self):
        return 3.14 * self.radius ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = heigh.t

    def area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate_area(self, shape):
        return shape.area()

Code that adheres DIP is:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

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

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

    def area(self):
        return 3.14 * self.radius ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = heigh.t

    def area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate_area(self, shape):
        return shape.area()

References

Geek For Geeks. "SOLID Principle in Programming: Understand With Real Life Examples". Retrieved from https://www.geeksforgeeks.org/solid-principle-in-programming-understand-with-real-life-examples/
Geek For Geeks. "OOD Principles | SOLID". Retrieved from https://www.geeksforgeeks.org/ood-principles-solid/

OOPs In Python

NK1FC — Thu, 16 Feb 2023 06:11:40 +0000

It allows users to create objects with their own attributes.
Method act as a function that uses some parameter and objects itself or only the object itself to return some value or change the object. ### General format for creating a class


class NameOfClass:  #use camel casing to write the class name.

    def __init__(self, x, y):
        self.x=x
        self.y=y

    def some_method(self):
        pass

Why use oops?

It makes the development and management of projects more manageable.
Feature of data hiding.
Reusability of code

OOPs concepts

Class
Object
Encapsulation
Abstraction
Polymorphism
Inheritance
Constructor
Destructor

Class

A class is a blueprint that is used to create an object.
It creates an object having the same attribute and methods.

class NameOfClass:  #use camel casing to write the class name.

    def __init__(self, x, y):
        self.x=x
        self.y=y

    def some_method(self):
        pass

Object

It is an entity that has a predefined attributes and method.

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

    def bark(self):
        print(f'{self.name} woof')

newdog=Dog('tom')
newdog.bark() 
#output- It will print 'tom woof'

All the objects created using class Dog the object will have an attribute name and a Method named bark().

Constructor

This will create object using the class.
init is used to create the object.

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


newdog=Dog('tom') # New object is constructed with attribute name tom.

Destructor

It is used to delete the object.
It uses del Keyword.

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


newdog=Dog('tom') # New object is constructed with attribute name tom.
del newdog # the object new dog will be deleted.

Encapsulation

Encapsulation allows us to hide the object's attributes and method from outside access.
Python doesn't have truly private or protected attributes and methods.
Attributes and methods that needed to be protected start with single underscore: _
Attributes and methods that needed to be private start with double underscore: __

class Person:

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

    def get(self):         # This method is used to get the name that is private.
        return self.__name

    def set(self, name):   # This method will take some input names and change the value of the attribute.
        self.__name = name

    def get_age(self):          # This method is used to get the age that is protected.
        return self._age

    def set_age(self, age):     # This method will take some input age and change the value of the attribute.
        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 f"My name is {self.__name}"

a=Person('Name',5)
print(a._Person__name) # accesing private variable it gives output Name
print(a._age) # acessing private variable it gives output age

a._Person__name='New Name' # change the private variable without using any method.
print(a.get_name())  # it return the name of object

Inheritance

Inheritance allows us to create a new class(Child class or derived class) based on another class(Parent class or base 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:
- Single Inheritance: Child class is derived using only one class.
- Multiple Inheritance: Child class is derived using more than one class.
- Multilevel Inheritance: In this child, class is inherited from the child class of another parent class
- Hierarchical Inheritance: Multiple child class is created using single parent class.
- Hybrid Inheritance: Inheritance of multiple types takes place

class Person:

    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 NewPerson(Person):                        # inheriting parent class in child class

    def speak(self):                # accessing parent class attribute.
        print("I am new person")

class AnotherPerson(Person):                        # 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 and changing the
        self.sport = sport              # child class attribute 

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

D = AnotherPerson("Bruno", 9, 'Football')
C = NewPerson("Missa", 6)

D.show()                    # accessing parent class method in child class
#output- My name is Bruno, and I am 9 years old.
D.speak()                   # child class accessing its own attributes
#output- My favorite sport is Football. 
C.show()                    # accessing parent class method in child class
#output- My name is Missa, and I am 6 years old.                        
C.speak()                   # child class accessing its own attributes
#output- I am new Person

Abstraction

Abstraction allows us to hide classes and methods not necessary for the user.
An abstract class in python can be made by setting the parent class of any class to ABC after importing it from abc (Abstract Class Bases).
If you need to create an abstract method also import abstractmethod from abc module.
After that, we can create an abstract method using the @abstractmethod decorator.

from abc import ABC, abstractmethod

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

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

class AnotherPerson(Person):

    def speak(self):
        print("I am another person")


bruno = AnotherPerson()         
bruno.speak()           # ignoring abstract method of abstract class
#output- I am another person
bruno.show()            # non-abstract method of the abstract class still works
#output- I am a Person
person= Person() #this will throw an error abstract class can't be instantiated.

Polymorphism

It simply refers that different classes can have the same method name and it also represents method overriding.
Polymorphism in Python can be achieved in two ways: method overriding 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 Person:
    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 NewPerson(Person):
    pass

class AnotherPerson(Person):

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

nemo = Person("Nemo", 2)
bruno = AnotherPerson("Bruno", 9)

nemo.speak()                        # parent's class method runs
#output- My name is Nemo and I am 2 years old.
bruno.speak()                       # child's class method runs
#output- Hello! 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 Person:

    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 AnotherPerson:

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

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

nemo =Person("Nemo", 2)
bruno = Another("Bruno", 9)

nemo.speak()                        # method of first-class runs
# output- My name is Nemo and I am 2 years old.
bruno.speak()                       # method of the second class with the same name runs
#output- Hello! My name is Bruno and I am 9 years old.

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), len(self), etc.
Dunder methods cannot be called, they run automatically when called by in-built python functions.

class Book:
    def __init__(self,title,author,page):
        self.title=title
        self.author=author
        self.page=page

    def __str__(self):
        return f'This {self.title} wrote by {self.author}'

    def __len__(self):
        return self.page

kid_book=Book('New Book', 'Myself', 15)

print(kid_book)
#output- This Newbook wrote by Myself
print(len(kid_book))
#output- 15

References

Geek For Geeks. "Types of inheritance Python". Retrieved from https://www.geeksforgeeks.org/types-of-inheritance-python/
Geek For Geeks. "self in Python class". Retrieved from https://www.geeksforgeeks.org/self-in-python-class
Geek For Geeks. "Polymorphism in Python". Retrieved from https://www.geeksforgeeks.org/polymorphism-in-python/?ref=gcse
Geek For Geeks. "Dunder or magic methods in Python". Retrieved from https://www.geeksforgeeks.org/dunder-magic-methods-python/

Python String Methods

NK1FC — Wed, 15 Feb 2023 06:48:43 +0000

1- capitalize()

Capitalizes the first letter of a string.

string = 'what is your name?'
capitalized = string.capitalize()
print(capitalized) # 'What is your name?'

2- lower()

Changes all characters in a string to lowercase.

string = 'What Is Your Name?'
lowered = string.lower()
print(lowered) # 'what is your name?'

3- upper()

Changes all characters in a string to uppercase.

string = 'What Is Your Name?'
uppered = string.upper()
print(uppered) # 'WHAT IS YOUR NAME?'

4- swapcase()

Interchange the cases of all characters in a string.

string = 'What Is Your Name?'
swapcased = string.swapcase()
print(swapcased) # 'WHAT IS YOUR NAME?'

5- title()

Capitalizes the first letter of each word in a string.

string = 'what is your name?'
titled = string.title()
print(titled) # 'What Is Your Name?'

6- strip()

Removes whitespace from the start and end of a string.

string = '  what is your name?  '
stripped = string.strip()
print(stripped) # 'what is your name?'

7- count()

Gives the number of occurrences of a substring in a string.

string = 'what is your name?'
counted = string.count('a')
print(counted) # 2

8- find()

Gives the index of the first occurrence of a substring in a string, or -1 if it is not present.

string = 'what is your name?'
found = string.find('is')
print(found) # 5

9- index()

Gives the index of the first occurrence of a substring in a string, or raises a ValueError if it is not present.

string = 'what is your name?'
indexed = string.index('your')
print(indexed) # 9

10- replace()

Interchange all occurrences of a substring in a string with another substring.

string = 'what is your name?'
replaced = string.replace('your', 'my')
print(replaced) # 'what is my name?'

11- format()

Formats a string using placeholders for variables or values.

string = 'what is your name?'
replaced = string.replace('your', 'my')
print(replaced) # 'what is my name?'

12- split()

Splits a string into a list of substrings using a specified delimiter.

formatted = 'My name is {name} and I am {age} years old'.format(name='NK', age=23)
print(formatted) # 'My name is Jane and I am 30 years old'

13- join()

Joins a list of strings into a single string using a specified character or symbols.

string = 'what is your name?'
splitted = string.split()
print(splitted) # ['what', 'is', 'your', 'name?']

14- startswith()

Gives True if a string starts with a specified substring, otherwise False.

joined = '-'.join(['what', 'is', 'your', 'name?'])
print(joined) # 'what-is-your-name?'

15- endswith()

Gives True if a string ends with a specified substring, otherwise False.

string = 'what is your name?'
startswith = string.startswith('what')
print(startswith) # True

Python List Methods

NK1FC — Wed, 15 Feb 2023 05:21:09 +0000

1- append(element)

Add the element at the end of the list.

 a=[1,2,3,4,5]
 a.append(6) # add the element to the end of the list
 print(a)
 # output-[1,2,3,4,5,6]

2- clear()

Remove all the elements of the list.

a=[1,2,3,4,5]
a.clear() #remove all the element
print(a)
# output-[]

3- copy()

Create a copy of the list.

a=[1,2,3,4,5]
b=a.copy() #copy of list
print(b)
# output-[1,2,3,4,5]

4- count(value)

Gives the count of the number of elements of the specified value.

a=[1,2,3,2,5,2]
b=a.count(2) #Count the number of elements of the specified value in the list.
print(b)
# output-3

5- extend(iterable)

Add all the elements of iterable(string, tuple, list, set) to the list

a=[1,2]
a.extend('abc') # char of string will be added a=[1, 2, 'a', 'b', 'c'].
a.extend([1,2]) # element of the list will be added a=[1, 2, 'a', 'b', 'c', 1, 2]
print(a)
# output-[1, 2, 'a', 'b', 'c', 1, 2]

6- index(element)

Return the index of the first occurrence of the element.

a=[1,2,3,2,5,2]
b=a.index(2) #the index of the first occurrence of 2.
print(b)
# output-1

7- insert(position, element)

Add the element at the specified position.

a=[1,2,3,2,5,2]
a.insert(2,'a') #Count the number of elements of the specified value in the list.
print(a)
# output-[1, 2, 'a', 3, 2, 5, 2]

8- pop(postion)

Remove the element at the specified position if the position is not mentioned then the last element will be removed

a=[1,2,3]
a.pop() #Remove the last element of the list.
a.pop(0) #Remove the element at 0 position
print(a)
# output-[2]

9- remove(element)

Remove the specified element at the first occurrence and throw an error if the element is not in the list.

a=[1,2,3,2,4,5]
a.remove(2) # remove the first occurrence of  2 from the list.
print(a)
# output-[1,3,2,4,5]

10- reverse()

Reverse the list

a=[1,2,3]
a.reverse()# Reverse the list.
print(a)
# output-[3,2,1]

11- sort()

Sort the list.

a=[3,1,2]
a.sort()# Sort the list.
print(a)
# output- [1,2,3]

References

Geek For Geeks. "List methods in Python". Retrieved from https://www.geeksforgeeks.org/list-methods-in-python/
Python. "Documentation". Retrieved from https://docs.python.org/3/tutorial/datastructures.html

Sed- 10 Practical Uses of Sed

NK1FC — Thu, 02 Feb 2023 05:44:10 +0000

sed

This command is used in order to searches through, replaces, adds, and deletes lines in a text file.

10 Practical Uses of Sed

Replace a specific word in a text file.

 sed 's/oldword/newword/g' file.txt

The s command stands for Replace and g stands for global. This command will replace all the oldword with newword in file.txt.

Remove blank lines from a file.

 sed '/^$/d' file.txt

^$ will match the blank lines and d represents delete the line it will delete all the blank lines in file.txt.

Replace characters in specific line numbers.

 sed '2s/oldchar/newchar/g' file.txt

'2' represents line number and on this line, command will replace all oldchar with newchar in file.txt.

Delete specific character in a file.

 sed 's/char//g' file.txt

char specify character to delete and //g will delete all the specified characters in file.txt.

Replace multiple characters in a file

sed 's/[char1char2]//g' file.txt

Inside square brackets specify all the characters that need to be deleted in file.txt.

Delete the last line of a file.

sed '$d' file.txt

$d delete the last line of a file.txt, where $ matches the last line.

Delete a range of lines in a file.

sed '10,20d' file.txt

This command deletes all the lines from 10 - 20 both lines included.

Print first 10 lines of file.

sed -n '1,10p' file.txt

The -n option suppresses automatic output, and 1,10p print lines from 1 to 10 inclusive.

Delete a range of lines in file.

sed '10,20d' file.txt

The 10,20d command deletes lines 10 to 20 inclusive in the file.

Insert a line before the first line of a file.

sed '1i\new-line' file.txt

1i insert the text "new-line" before the first line of the file.