Forem: AJITH D R

Django Review Points

AJITH D R — Tue, 04 Apr 2023 12:29:45 +0000

Settings file

What is secret key?

A Secret key is a unique and random string of characters that is used for cryptograpic signing and to protect sensitive information in Django. It is used to sign cookies, CSRF tokens, and other secure data in Django.

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

django.contrib.admin - provides a web-based admin interface for managing the application data.
django.contrib.auth - provides authentication functionality.
django.contrib.contenttypes - allows defining and managing content types for models.
django.contrib.sessions - provides session management functionality.
django.contrib.messages - provides a messaging framework for sending notifications and alerts to users.
django.contrib.staticfiles - provides a way to manage static files such as CSS, JavaScript, and images.
django.contrib.sites - provides a framework for managing multiple sites on a single Django installation.

What is middleware? What are different kinds of middleware?

Read up a little on each security issue.**
Middlware is a set of components that sit between the web server and the view, and can perform various operations on requests/responses. It can be used for modifying requests/responses, authentication, caching and security.
Types of middleware:

Process Request Middleware: It is called before view is executed and can be used to modify the incoming request, authenticate the user, or perform security checks.
View Middleware: It is called after the view is executed and can be used to modify the response, perform additional authentication or authorization checks, or add additional data to the context.
Template Response Middleware: It is called after the view has generated a response and can be used to modify the response before it is rendered by the template.
Exception Middleware: It is called when an exception occurs during the request-response cycle and can be used to handle and log the exception, or display a custom error page.

Security issues:

Cross-Site Scripting (XSS) Attacks: XSS attacks occur when a malicious user injects script code into a web page, which can then be executed by other users who visit the page.
Cross-Site Request Forgery (CSRF) Attacks: CSRF attacks occur when a malicious website sends a request to a site on behalf of an authenticated user, without the user's knowledge or consent.
SQL Injection Attacks: SQL injection attacks occur when a malicious user injects SQL code into a database query, allowing them to access or modify data in the database.
Authentication and Authorization Issues: Improperly implemented authentication and authorization systems can lead to security vulnerabilities such as password cracking, session hijacking, and privilege escalation.
File Upload Security: File upload functionality can be vulnerable to security issues such as file tampering and file inclusion attacks.

What is WSGI

WSGI stands for Web Server Gateway Interface. It's a specification for a universal interface between web servers and web applications or frameworks written in Python. The WSGI specification defines a set of rules and guidelines that enable Python web applications to communicate with web servers.
WSGI allows web servers like Apache or Nginx to talk to Python web applications like Django or Flask. When a request comes into the web server, the server passes the request to the Python web application through the WSGI interface. The application processes the request and returns a response to the web server, which then sends the response back to the client that made the request.

Models file

What is ondelete Cascade?

on_delete=cascade is an option that can be specified when defining a ForeignKey field in a database model. It specifies what should happen when the referenced object in the ForeignKey relationship is deleted.
When on_delete=cascade is specified, it means that when the referenced object is deleted, all objects that have a ForeignKey to it will also be deleted. This behavior is called "cascade deletion".

A broad understanding of Fields and Validators available to you

Fields are used to define the types of data that can be stored in a database model. Django provides a wide range of fields for different types of data, such as CharField for short strings, TextField for long text, IntegerField for integers, FloatField for floating-point numbers, BooleanField for true/false values, and many others.

Validators are used to validate user input in forms. Django provides several built-in validators for different types of data, such as EmailValidator for validating email addresses, MaxLengthValidator for enforcing maximum lengths on text fields, and MinValueValidator for enforcing minimum values on numeric fields.

Understanding the difference between Python module and Python class?

A module is a file that contains Python code, usually with a specific purpose or functionality. A module can define functions, classes, variables, and other objects that can be used by other programs or modules.

A class is a blueprint for creating objects that define a set of attributes and methods. A class is like a template or a factory for creating objects that share common characteristics and behaviors.

Django ORM

Using ORM queries in Django Shell

Run the Django shell by typing python manage.py shell in the terminal.
Once you're in the shell, you can import your Django models by typing from my_app.models import Car
Retrieve all objects from a model

all_objects = Car.objects.all()

Retrieve a single object by its primary key

single_object = Car.objects.get(pk=1)

Filter objects based on specific criteria

filtered_objects = Car.objects.filter(mileage=15)

Update an object

car.mileage = 20
car.save()

Delete an object

car.delete()

Turning ORM to SQL in Django Shell

Every queryset object has query attribute, which holds the actual SQL query which will be sent to Database. query attribute return query when either print or convert it to str.

q = MyModel.objects.all()
print(q.query)

What are Aggregations?

Aggregations refer to the process of performing calculations across a set of related objects in the database.
Count - Returns the number of objects in a QuerySet.

Sum - Calculates the sum of values for a particular field in a QuerySet.

Avg - Calculates the average value for a particular field in a QuerySet.

Max - Returns the maximum value for a particular field in a QuerySet.

Min - Returns the minimum value for a particular field in a QuerySet.

StdDev - Calculates the standard deviation of a particular field in a QuerySet.

Variance - Calculates the variance of a particular field in a QuerySet.

What are Annotations?

Annotations are used to add calculated fields to QuerySets that are not present in the database. Annotations allow you to perform complex calculations on related objects and add the results to the QuerySet as an additional field.

Annotations can be used with various aggregation functions and are a powerful tool for customizing the data returned by QuerySets.

Use an aggregation function to calculate a value for an annotation:

from django.db.models import Count

# Add a new field to the QuerySet that counts related objects
q = MyModel.objects.annotate(num_comments=Count('comments'))

What is a migration file? Why is it needed?

A migration file is a Python file generated by Django's migration framework that describes changes to a database schema. Migration files are used to manage changes to database models and can be used to create or modify database tables, indexes, constraints, and other schema elements.
Some examples of operations that can be included in a migration file are:

Creating a new table
Adding a new column to an existing table
Removing a column from an existing table
Modifying a column in an existing table
Creating or removing an index
Creating or removing a constraint

Once you have created a migration file, you can apply the changes to the database using the migrate management command. This command reads the migration files in your project and applies the changes to the database schema in the correct order.

What are SQL transactions? (non ORM concept)

SQL transactions group a series of database operations into a single unit of work.
Transactions are atomic, meaning they either succeed or fail as a single unit.
Transactions must ensure that the database remains in a valid state before and after the transaction.
Transactions are executed in isolation from other transactions to ensure consistency.
Once a transaction is committed, its effects are permanent and cannot be undone.
SQL transactions are used in applications that require reliable and consistent access to a database.

What are atomic transactions?

Atomic transactions are like a single unit of work, where a set of actions are either completed successfully all together, or none of them are executed at all. It's like a switch that turns all the lights on, or none of them, without leaving any halfway states.
In Django's ORM, you can use the atomic decorator or context manager to support atomic transactions. When you wrap a block of code in an atomic block, it guarantees that either all the database operations within that block will succeed, or none of them will be executed at all. This helps to make your code robust and reliable.

HTML/CSS Concepts

AJITH D R — Thu, 02 Mar 2023 08:10:44 +0000

Box Model

In web development, the CSS box model is a rectangular structure that encloses each HTML element and includes the content itself, as well as padding, borders, and margins. The below diagram shows these layers:

content: encompasses text and images within the box.
padding: surrounds the content and is transparent
border: outlines the padding and content.
margin: lies outside the border and is transparent.

If we assume that a box has the following CSS:
The actual space taken up by the box will be 410px wide (350 + 25 + 25 + 5 + 5) and 210px high (150 + 25 + 25 + 5 + 5).

.box {
  width: 350px;
  height: 150px;
  margin: 10px;
  padding: 25px;
  border: 5px solid black;
}

Inline vs Block Elements.

Block-level elements are automatically positioned on a new line by browsers and have a margin added before and after the element. They occupy the full available width, extending both to the left and right as far as possible. Examples of popular block-level elements include <p>, <form> , <div>, etc.
An inline element is positioned without starting a new line. An inline element occupies only the required width. Examples of popular inline elements include <span>, <a>, <img>, etc.

Positioning: Relative/Absolute

Relative Positioning:

When an element is positioned relatively, it remains in the normal flow of the page, but its position can be adjusted relative to its default position.
The element's position is set using the same top, bottom, left, and right properties as absolute positioning, but the values are relative to the element's original position.

Absolute positioning:

When an element is positioned absolutely, it is removed from the normal flow of the page and positioned relative to its nearest positioned ancestor. If there is no positioned ancestor, it will be positioned relative to the initial containing block.
The element's position is set using the top, bottom, left, and right properties.

Common CSS structural classes

:first-child - Selects first child element under the parent element when first child element is a specified element.
:last-child - Selects last child element under the parent element when last child element is a specified element.
:first-of-type - Selects first child element of its type under the parent element.
:last-of-type - Selects last child element of its type under the parent element.
:only-child - Selects a specified element if it is the only child element under the parent element.
:nth-of-type(n) - Selects one or more child elements based on its type under the parent element.
:nth-last-of-type(n) - Selects one or more child elements based on its type under the parent element.
:not - This takes simple selector as an argument and selects elements that are not represented by the argument.
:empty - Selects empty elements.
:root - Selects root element.

Common CSS styling classes

Container: It is usually defined using the class attribute in HTML and styled in CSS.
Row: A row class is used to define a horizontal row of elements within a container.
Column: A column class is used to define a vertical column of elements within a row.
Header: A header class is used to define the top section of a web page, which typically includes the site logo, navigation menu, and other important information.
Footer: A footer class is used to define the bottom section of a web page, which typically includes copyright information, contact details, and links to social media accounts.
Sidebar: It is often used to display additional navigation links or other secondary content.
Navigation: A navigation class is used to define a menu of links that allows users to navigate through different sections of the website.
Content: A content class is used to define the main section of a web page, which typically includes the main text, images, and other media.

CSS Specificiy

Specificity determines, which CSS rule is applied by the browsers.
Every selector has its place in the specificity hierarchy. If two selectors apply to the same element, the one with higher specificity wins.
The embedded style sheet has a greater specificity than other rules.
ID selectors have a higher specificity than attribute selectors.
A class selector beats any number of element selectors.
Universal selectors applied at last.

CSS Responsive Queries

CSS responsive queries are also known as media queries. They allow you to apply different styles to a webpage based on the screen size, orientation, and other characteristics of the device on which it is being viewed.

Basic media query to target smaller screens:

@media (max-width: 768px) {
   /* This query targets screens with a maximum width of 768 pixels, and applies styles only when the screen is narrower than that. */
}

Media query to target larger screens:

@media (min-width: 992px) {
   /* This query targets screens with a minimum width of 992 pixels, and applies styles only when the screen is wider than that. */
}

Flexbox

Flexbox is a layout mode in CSS that allows you to create flexible and responsive layouts with a single container element and its child elements.
Flexbox has two main axis: the main axis and the cross axis. By default, the main axis is horizontal and the cross axis is vertical.
To use flexbox, we need to set the display property of the container element to flex. For example:

.container {
   display: flex;
}

To Center the child elements along the main axis.

.container {
   display: flex;
   justify-content: center;
}

To center the child elements along the cross axis.

.container {
   display: flex;
   align-items: center;
}

To switch the main axis to vertical.

.container {
   display: flex;
   flex-direction: column;
}

To allow the child elements to wrap to the next line.

.container {
   display: flex;
   flex-wrap: wrap;
}

Grid

CSS grid is a two-dimensional layout system that allows you to create complex layouts for websites.
To create a grid, we need to define a container element and set it to display: grid.

The grid container can be divided into rows and columns using the grid-template-rows and grid-template-columns properties.

<div class="grid-container">
  <div class="grid-item">1</div>
  <div class="grid-item">2</div>
  <div class="grid-item">3</div>
  <div class="grid-item">4</div>
  <div class="grid-item">5</div>
  <div class="grid-item">6</div>
</div>

.grid-container {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-template-rows: repeat(2, 100px);
  grid-gap: 10px;
}

.grid-item {
  background-color: #ccc;
  padding: 20px;
}

In this example, we have a grid container with six grid items. We've set the grid-template-columns property to repeat three columns, each with a width of 1fr, and the grid-template-rows property to repeat two rows, each with a height of 100px. We've also added a grid gap of 10px between rows and columns. The result is a 3x2 grid with six equally sized cells.

Common header meta tags

Description tag - This tag provides a brief description of the web page.

<head>
  <meta name="description" content="This is an example description of the web page.">
</head>

Keywords tag - This tag lists keywords that are relevant to the content on the web page.

<head>
  <meta name="keywords" content="example, keywords, web page">
</head>

Author tag - This tag specifies the name of the author of the web page.

<head>
  <meta name="author" content="John Doe">
</head>

Robots tag - This tag specifies whether or not search engine robots should index or follow the web page.

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

Viewport tag - This tag specifies the viewport settings for the web page.

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

Charset tag - This tag specifies the character set used in the web page.

<head>
  <meta charset="UTF-8">
</head>

References:

-CSS Flexbox, W3Schools

Revision - 25/02/2023

AJITH D R — Sat, 25 Feb 2023 06:43:38 +0000

1.When do we use UNION operator in SQL?

We use UNION operator when we want to combine two or more SELECT statements. UNION also combines two or more tables into a single result set. UNION selects distinct rows and avoids duplicates.

2.What are the different subsets of SQL?

Data Definition Language (DDL): It allows you to perform various operations on the database such as CREATE, ALTER, and DELETE objects.
Data Manipulation Language(DML): It allows you to access and manipulate data. It helps you to insert, update, delete and retrieve data from the database.
Data Control Language(DCL): It allows you to control access to the database. Example – Grant, Revoke access permissions.

3.What are the difference between BCNF and 4NF?

In fourth normal form, there are no multi-valued dependencies of the tables, but in BCNF, there can be multi-valued dependency data in the tables.

4.If you are working on mutiple git branches how do we switch to a particular branch?

Check all the branches present in git reposiotry

git branch

Switch to particular branch

git checkout <branchname>

5.How do you change commit message of previous commit ?

git commit --amend -m '<commit message>'

6.In linux, whenever we run a program, we give flags. Some use '-' and some use '--'. What is the difference ?

A single hyphen can be followed by multiple single-character flags. A double hyphen prefixes a single, multicharacter option.

7.What are block elements and inline elements in HTML?

Block-level elements are elements that take up the full width of their parent container and create a new line after the element.
Inline elements, on the other hand, are elements that only take up as much width as necessary and do not create a new line after the element.

8.What is the kernel and shell, and how are they related ?

The kernel is the core of the operating system that interacts directly with the hardware. The kernel is responsible for managing system processes, scheduling tasks, handling memory management, and managing device drivers.
The shell, on the other hand, is a user interface that allows users to interact with the operating system. It provides a command-line interface or graphical user interface (GUI) for users to run commands, launch applications, and manage files and directories.
The kernel and shell are both key components of an operating system. The kernel is responsible for managing system resources and interacting with the hardware, while the shell provides a user interface for users to interact with the operating system. They work together to manage the computer system and execute user commands and tasks.

9.What is the git command to see all the commits of a particular file?

git log --all <file_name>

10.What is the use of "eq" dunder method in python ?

To change how Python checks if two things are equal using the "==" operator, we can create a special function in our class called "eq". This function will be called when we use the "==" operator on objects of our class. If we don't define this function, Python will use a default method that checks if two objects are stored in the same location in the computer's memory.

11.What is the difference between rem and em in CSS?

rem stands for "root em", and is always relative to the font-size of the root element (i.e., the html element). For example, if the font-size of the root element is set to 16px, then 1rem is equal to 16px. If the font-size of the root element is changed, then all rem values will be affected accordingly.
em stands for "element em", and is relative to the font-size of the element that the em value is applied to. For example, if a paragraph element has a font-size of 16px, then 1em is equal to 16px. If the font-size of a parent element is changed, then all em values inside that element will be affected accordingly.

12.What are mutable objects in python and what is the best way to identify them ?

Mutable objects can be changed after they are created.
The best way to identify whether an object is mutable or not is to try to modify it and see if the modification is reflected in the original object.
To identify whether an object is mutable or not, we can use the id() function in Python. The id() function returns a unique integer identifier for an object, which can be used to determine if two variables refer to the same object.

>>> my_list = [1, 2, 3]
>>> my_tuple = (1,2,3)
>>> print(id(my_list))
139941828301888
>>> print(id(my_tuple))
139941826669696
>>> my_list += [4,5,6]
>>> my_tuple += (4,5,6)
>>> print(id(my_list))
139941828301888
>>> print(id(my_tuple))
139941828542624

We can see that the list identity is not changed, while the tuple identity is changed. This means that we have expanded our list, but created a completely new tuple.

13.Why we should not use multiple inheritance in software development ?

Complexity: Multiple inheritance can increase the complexity of a codebase. When a class inherits from multiple parent classes, it may be difficult to determine which parent's implementation of a method should be used in a particular scenario. This can lead to confusion and errors.
Diamond problem: The diamond problem is a common issue in multiple inheritance where a class inherits from two parent classes that both inherit from a common parent. This can lead to ambiguity in the inheritance hierarchy, making it difficult to determine which parent's implementation should be used.

14.What is the difference between strongly type and weakly typed language ?

In a strongly typed language, variables have a specific data type, and the language enforces strict rules about how variables of different types can be used. For example, in a strongly typed language like Java, we cannot assign a string value to an integer variable without first converting the string to an integer. The compiler will enforce this rule at compile-time, preventing type-related errors from occurring at runtime.
In a weakly typed language, variables are not required to have a specific data type, and the language may automatically convert between different data types as needed. For example, in a weakly typed language like JavaScript, we can assign a string value to a variable declared as an integer, and the language will automatically convert the string to an integer if possible.

15.What is the difference between statically typed and dynamically typed language?

Statically typed languages requires to declare the data type of a variable before it can be used. This means that the compiler can check the type of each variable at compile time, ensuring that only values of the correct type are assigned to each variable. Examples of statically typed languages include Java, C++, and C#.
Dynamically typed languages, on the other hand, do not require variables to be declared with a specific data type. Instead, the type of a variable is determined at runtime based on the value assigned to it. This allows for more flexibility in programming and can make the code easier to read and write. Examples of dynamically typed languages include Python, Ruby, and JavaScript.

16.How do you give space between flex items (CSS) ?

Using gap property. The gap property sets the gaps between rows and columns. It is a shorthand for row-gap and column-gap.

SQL Concepts

AJITH D R — Wed, 22 Feb 2023 06:25:45 +0000

ACID Properties

ACID properties are a set of properties that ensures the consistent state before and after the transaction.

1. Atomicity:

Atomicity property says that, when an action is performed on the data, it should either be executed completely or not executed at all.

Suppose there's an application that transfers funds between accounts. In this case, the property of atomicity guarantees that when a withdrawal is made from one account, the corresponding deposit is also made to the other account, ensuring a successful transaction. If any part of the transaction fails due to insufficient funds, the entire transaction is rolled back to its initial state.

2. Consistency:

The consistency property of a transaction ensures that the data is in a valid state both before the transaction begins and after it completes.

For instance, when performing a fund transfer from one account to another, the consistency property guarantees that the total amount of funds in both accounts remains constant at the beginning and end of each transaction.

3. Isolation:

In a system where multiple transactions are running simultaneously, the intermediate phase of each transaction is not visible to other transactions. This implies that the concurrent transactions seem to be executed sequentially.

For instance, suppose an application that transfers funds from one account to another. In that case, the isolation property guarantees that any other transaction will only see the transferred funds in one account or the other, but not in both accounts or neither of them.

4: Durability:

Once a transaction has been executed successfully, any modifications made to the data are permanent and will not be reverted, even if there is a system malfunction.

For instance, consider an application that transfers money from one account to another. In such a scenario, the durability property ensures that any modifications made to the accounts involved in the transaction will be preserved and will not be rolled back.

CAP Theorem

CAP theorem states that, In a distributed systems, it is not possible to guarantee all three properties - consistency, availability, and partition tolerance at the same time.

Consistency means that all nodes will have same data at the same time. Every client will read the same data no matter what node they are connected to.
Availability ensures that even if one or more nodes are down, any client making a request to a node for data will gets a response.
Partition tolerance means that the system must continue working even if there is a communication break within the system.
Since the networks are not completely reliable, we must tolerate partitions in a distributed systems. According to CAP theorem, we can have only two properties at the same time, so with partition tolerance we can have consistency or availability.
CP: CP based system provides consistency and partition tolerance. When a communication break occurs between any two nodes, the system has to make the non-consistent node unavailable till the partition is resolved.
AP: AP based systems provides availability and partition tolerance.
When a communication break occurs, all nodes will be available to the clients but non-consistent nodes might return older data than other nodes.

Joins

Joins in SQL is used to combine columns of two or more tables based on the common columns between the tables being joined.
There are various types of joins:

Inner join
Left join
Right join
Full join
Self join
Cross join

The examples that I have used here are sourced from here.
Consider the following two tables:
Table 1 - CUSTOMERS Table.

Table 2 - ORDERS Table.

INNER JOIN:

INNER JOIN is also referred to as EQUIJOIN. It joins all rows from the intended tables if they meet the stated condition.
If we want to get all the records from two tables that have common customer id, we can get it using inner join.

SELECT  ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This will produce the following output:

LEFT JOIN:

Left Join returns all the records from the Left Table and only the matching records from the right table.

SELECT  ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

RIGHT JOIN:

Right Join returns all the records from the Right table and only the matching records from the left table.

SELECT  ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

FULL JOIN:

The SQL FULL JOIN combines the results of both left and right joins.

SELECT  ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

SELF JOIN:

The SELF JOIN is used to join a table to itself. This means that each row in a table is joined to itself and every other row in that table.

SELECT  a.ID, b.NAME, a.SALARY
FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY < b.SALARY;

Cross Join:

Cross Join returns the cartesian product of the two tables. That means, it produces a paired combination of each row of the first table with each row of the second table.

SELECT  ID, NAME, AMOUNT, DATE
FROM CUSTOMERS, ORDERS;

Aggregations, Filters in queries:

Aggregate function operates on a set of values and returns a single value.

Consider the following table 'Random_numbers':

numbers
12
10
13
97
100

Commonly used SQL Aggregate functions are:

COUNT(): This function returns the number of items in a set.

SELECT COUNT(numbers) FROM Random_numbers;

-- output: 5

AVG(): This function returns the average of a set.

SELECT AVG(numbers) FROM Random_numbers;

-- output: 46.4

SUM(): This function returns the sum of all values in a set.

SELECT SUM(numbers) FROM Random_numbers;

-- output: 232

MIN(): This function returns the minimum value in a set.

SELECT MIN(numbers) FROM Random_numbers;

-- output: 10

MAX(): This function returns the maximum value in a set.

SELECT MAX(numbers) FROM Random_numbers;

-- output: 100

Filters:

AND:

The AND operator allows the existence of multiple conditions in an SQL statement WHERE clause

SELECT CustomerID, InvoiceId, Total
FROM Invoice
WHERE Total >= 10 AND Total =< 13;

OR:

The OR operator combines multiple conditions in an SQL statement’s WHERE clause.

SELECT FirstName, LastName, City 
FROM Customer 
WHERE City = 'London' OR City ='Paris' OR City='Milan';

NOT:

The NOT operator reverses the meaning of the logical operator with which it is used; eg, NOT BETWEEN, NOT IN.

SELECT FirstName, LastName, City
FROM Customer
WHERE City NOT IN ('London', 'Paris', 'Milan');

BETWEEN:

The BETWEEN operator searches for values that are within a set of values, given the minimum value and the maximum value.

SELECT CustomerID, InvoiceId, Total
FROM Invoice
WHERE Total BETWEEN 10 AND 13;

IN:

The IN operator compares a value with a list of literal values that have been specified.

SELECT FirstName, LastName, City 
FROM Customer 
WHERE City IN ('London', 'Paris', 'Milan');

LIKE:

The LIKE operator compares a value with similar values, using wildcard operators.

SELECT Composer, Name 
FROM Track 
WHERE Name LIKE '%Rock%';

Normalization

Normalization helps to reduce or remove data redundancy in a database. It is important to remove redundancy since it causes anomalies in a database which makes it hard to maintain it.

There are four types of normal forms:

First Normal Form (1NF)
For a table to be in the First Normal Form,

It should only have atomic valued attributes.
Values stored in a column should be of the same domain.
All the columns in a table should have unique names.
And the order in which data is stored, does not matter.

Second Normal Form (2NF)
For a table to be in the Second Normal Form,

It should be in the First Normal Form.
And, it should not have Partial Dependency(Non prime attribute(s) should not depend on part of the candidate key).

Third Normal Form (3NF)
For a table to be in the Third Normal Form,

It should be in the Second Normal Form.
It should not have Transitive Dependency(A functional dependency X → Y in a relation R is a transitive dependency if there is a set of attributes Z that is not a subset of any key of R, and both X → Z and Z → Y hold).

Boyce-Codd Normal Form (BCNF)
For a table to be in BCNF, it must satisfy the following rules:

The table must be in the third normal form.
For every non-trivial functional dependency X -> Y, X is the superkey of the table. That means X cannot be a non-prime attribute if Y is a prime attribute. A superkey is a set of one or more attributes that can uniquely identify a row in a database table.

Indexes

Indexing is a technique used to optimize the speed of retrieving data. Indexing helps to speed up queries by allowing the database to quickly find the relevant data.

For example, consider a table called 'Employees' which contains information about employees, such as their firstname, lastname, emailId, Salary, location. Now if we want to search for all the employees who live in a particular location, the DBMS will scan the entire table to find the required records which makes it slower.
But, if we create an index on the location, the DBMS use that index to quickly find the required records.
Example to create an index:

CREATE INDEX employees_by_location
ON Employees (location)

Transactions

A Transaction is a set of operations performed on a database, which is treated as a single operation.
A transaction can include multiple operations on the database, but if any one of those operations fails, the entire transaction is rolled back, and the database returns to its original state.
Transaction has four properties which maintains consistency in a database, before and after transaction: Atomicity, Consistency, Isolation and Durability.

Locking Mechanism

The locking mechanism allows the database to produce sequential output without sequential steps. Locks provide a way to protect data in use from anomalies, such as data loss or additional data that may be added due to a lost transaction.

Two-Phase Locking Protocol
Each transaction locks and unlocks items in two different steps.

Growth Phase - All locks are executed in this phase. Locks are not released after the second phase (compact phase) starts after all changes have been committed.

Compact Phase - In this phase no locks are issued, all changes to the data item are saved and then the locks are released.

In the grow phase, a transaction reaches a point where it has already acquired all the locks it needs. This point is called the LOCK POINT.

After reaching the blocking point, the transaction enters the compression phase.

Database Isolation Levels

Database isolation levels refer to the degree to which different transactions in a database are isolated from one another.

Read Uncommitted(Level 0): This isolation level allows transactions to read uncommitted data that has not yet been written to the database. This can lead to dirty reads, where transactions read data that has been modified by another transaction but has not yet been committed.
Read Committed (Level 1): This isolation level prevents other transactions from writing to or reading from rows that other transactions have written but have not yet committed. So it doesn't allow dirty reading. A transaction holds a read or write lock on the current row, so other transactions cannot read, update, or delete that row.
Repeatable Read (Level 2): This isolation level ensures that any transaction that reads data from a row blocks other write transactions accessing the same row. This is the most restrictive isolation level and holds read locks on all rows it references and holds write locks on all rows it inserts, updates, or deletes. No other transaction can read, update, or delete these rows, preventing non-repeatable reads.
Serializable (Level 3): This isolation level is the highest isolation level. A serializable isolation level requires much more than restricting access to a single row. Typically, this isolation mode locks the entire table to prevent other transactions from inserting or reading data from the table.

Triggers

Trigger are the SQL statements that runs automatically in response to certain events or changes to a table. Triggers can be used to perform actions such as updating a table or sending an email whenever specific data is inserted, updated, or deleted from a table.

Syntax:

create trigger Trigger_name
(before | after)
[insert | update | delete] 
on [table_name]  
[for each row]  
[trigger_body]

"CREATE TRIGGER" - Used to make a new trigger.
"TRIGGER_NAME" - Name of the trigger, and it has to be unique.
"BEFORE" or "AFTER" - Specifies when the trigger should happen, either before or after an event.
"INSERT", "UPDATE", or "DELETE" - Events that can activate the trigger.
"ON [TABLE_NAME]" - Specifies the table that the trigger is connected to.
"FOR EACH ROW" - means the trigger is triggered for each row in the table.
"TRIGGER_BODY" contains the SQL queries that the trigger will execute when it's activated.

Here's a simple SQL trigger example that automatically updates a "last_updated" column in a table called "orders" whenever a new row is inserted into the table:

CREATE TRIGGER update_last_updated
AFTER INSERT ON orders
FOR EACH ROW
BEGIN
   UPDATE orders
   SET last_updated = NOW()
   WHERE id = NEW.id;
END;

References:

SOLID Design Principles

AJITH D R — Mon, 20 Feb 2023 06:46:10 +0000

SOLID Design Principles are a set of five design principles introduced by Robert C. Martin. These principles help developers build maintainable, flexible and scalable software systems.
SOLID is an acronym for the following design principles:

Single Responsibility Principle.
Open-Closed Principle.
Liskov Substitution Principle.
Interface Segregation Principle.
Dependency Inversion Principle.

Single Responsibility Principle(SRP):

SRP says that a class should have only one responsibility and should have only one reason to change.

For instance, we have a class called 'Order' that represents a customer's order at a restaurant. The Order class has two responsibilities: handling the order items and printing the receipt.

class Order:
    def __init__(self, order_items):
        self.order_items = order_items

    def calculate_total(self):
        # logic to calculate total cost of order
        pass

    def print_receipt(self):
        # logic to print receipt
        pass

The above implementation violates SRP since it has two responsibilities. We can separate these responsibilities into two classes.

class Order:
    def __init__(self, order_items):
        self.order_items = order_items

    def calculate_total(self):
        # logic to calculate total cost of order
        pass

class ReceiptPrinter:
    def print_receipt(self, order):
        # logic to print receipt
        pass

The 'Order' class is now responsible for handling the order items, and the 'ReceiptPrinter' class is responsible only for printing the receipt. This separation makes it easier to update or replace the receipt printing logic in the future without affecting the 'Order' class.

Open-Closed Principle(OCP):

The OCP states "Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification".

Suppose we have an existing 'Product' class that represents a product in the store, with properties such as 'name', 'price' and 'description'.

class Product:
    def __init__(self, name, price, description):
        self.name = name
        self.price = price
        self.description = description

    def get_price(self):
        return self.price

Now suppose we were to add a new feature where we offer discounts on certain products. We can apply OCP here by creating a new 'DiscountProduct' subclass that inherits 'Product' class without modifying the 'Product' class.

class Product:
    def __init__(self, name, price, description):
        self.name = name
        self.price = price
        self.description = description

    def get_price(self):
        return self.price

class DiscountedProduct(Product):
    def __init__(self, name, price, description, discount):
        super().__init__(name, price, description)
        self.discount = discount

    def get_price(self):
        discounted_price = super().get_price() - self.discount
        return max(discounted_price, 0)

The 'DiscountedProduct' class overrides the 'get_price' method of the Product class to return the discounted price of the product.

# Usage
product = Product("Shirt", 20, "A basic shirt")
print("Product price:", product.get_price())

discounted_product = DiscountedProduct("Jacket", 100, "A warm jacket", 25)
print("Discounted product price:", discounted_product.get_price())

By applying the OCP in the above example, we have made our code more maintainable and flexible. If we want to add new features in the future, we can create new subclasses of 'Product' without modifying existing code. This makes our code more scalable and less prone to errors.

Liskov substitution principle(LSP):

Liskov Substitution Principle states that "Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program."

Let’s take an example of class 'Car' that would indicate the type of a car. The 'PetrolCar' class inherits the 'Car' class.

class Car:
    def __init__(self, type):
        self.type = type

class PetrolCar(Car):
    def __init__(self, type):
        self.type = type

car = Car('SUV'):
car.properties = {'color': 'Red', 'gear': 'Auto', 'capacity': 6}
print(car.properties)

petrol_car = PetrolCar('Sedan')
petrol_car.properties = ('Blue', 'Manual', 4)
print(petrol_car.properties)

Output:
{'color': 'Red', 'gear': 'Auto', 'capacity': 6}
('Blue', 'Manual', 4)

In the above example, adding car properties does not follow any standard and it is upto the developers to implement it as a dictionary or tuple or other ways.

Now, if we want to find all the red-coloured cars based on the current implementation.

cars = [car, petrol_car]

def find_red_cars(cars):
    red_cars = 0
    for car in cars:
        if car.properties['color'] == 'Red':
            red_cars += 1
    print(f'Number of Red Cars = {red_cars}')

find_red_cars(cars)

# TypeError: tuple indices must be integers or slices, not str

Here, the implementation breaks the LSP as we cannot replace Car's object with its subclass PetrolCar's object in the function written to find red-colored cars.

So how can we fix this?, we can implement getters and setters methods in the Car's class using which we can set and get the properties of the Car without leaving the decision to developers on how to implement Car's properties.

class Car:
    def __init__(self, type):
        self.type = type
        self.car_properties = {}

    def set_properties(self, color, gear, capacity):
        self.car_properties = {'color': color, 'gear': gear, 'capacity': capacity}

    def get_properties(self):
        return self.car_properties

class PetrolCar(Car):
    def __init__(self, type):
        self.type = type
        self.car_properties = {}

car = Car('SUV'):
car.set_properties('Red', 'Auto', 6)

petrol_car = PetrolCar('Sedan')
petrol_car.set_properties('Blue', 'Manual', 4)

cars = [car, petrol_car]

def find_red_cars(cars):
    red_cars = 0
    for car in cars:
        if car.get_properties()['color'] == 'Red':
            red_cars += 1
    print(f'Number of Red Cars = {red_cars}')

find_red_cars(cars)

Output: Number of Red Cars = 1

Interface Segregation Principle(ISP):

The ISP states that clients should not be forced to depend on methods they do not use. In other words, it is better to have multiple small interfaces, each serving a specific purpose, rather than a single large interface with many methods.
Suppose we have a Communicator interface that includes methods for making calls, sending messages, and browsing the internet.

Now, if we want to implement a Landline phone which is a communication device, we create a new class LandlinePhone using the same CommunicationDevice interface. This is exactly when we face the problem due to a large CommunicationDevice interface we created. In the class LanlinePhone, we implement the make_calls() method, but as we also inherit abstract methods send_sms() and browse_internet() we have to provide an implementation of these two abstract methods also in the LandlinePhone class even if these are not applicable to this class LandlinePhone. We can either throw an exception or just write pass in the implementation, but we still need to provide an implementation.

from abc import ABC, abstractmethod

class Communicator(ABC):
    @abstractmethod
    def make_call(self, number):
        pass

    @abstractmethod
    def send_message(self, number, message):
        pass

    @abstractmethod
    def browse_internet(self):
        pass

class SmartPhone(CommunicationDevice):
  def make_calls(self, number):
    #implementation
    pass

  def send_sms(self, number, message):
    #implementation
    pass

  def browse_internet(self):
    #implementation
    pass

  class LandlinePhone(CommunicationDevice):
    def make_calls(self, number):
      #implementation
      pass

    def send_sms(self, number, message):
      #just pass or raise exception as this feature is not supported 
      pass

    def browse_internet(self):
      #just pass or raise exception as this feature is not supported
      pass

Instead of creating a large interface, we can create a smaller interfaces for each method.

from abc import ABC, abstractmethod

class CallingDevice:
  @abstractmethod
  def make_calls(self, number):
    pass

class MessagingDevice:
  @abstractmethod
  def send_sms(self, number, message):
    pass

class InternetbrowsingDevice:
  @abstractmethod
  def browse_internet(self):
    pass

class SmartPhone(CallingDevice, MessagingDevice, InternetbrowsingDevice):
  def make_calls(self, number):
    #implementation
    pass

  def send_sms(self, number, message):
    #implementation
    pass

  def browse_internet(self):
    #implementation
    pass

class LandlinePhone(CallingDevice):
  def make_calls(self, number):
    #implementation
    pass

Dependency Inversion Principle(DIP):

The Dependency Inversion Principle states that:

High level module should not depend on low level modules. Both should depend on abstractions
Abstractions should not depend on details. Details should depend on abstractions.

class LightSwitch:
    def __init__(self, light):
        self.light = light

    def turn_on(self):
        self.light.turn_on()

    def turn_off(self):
        self.light.turn_off()

class Light:
    def turn_on(self):
        # Code to turn on the light

    def turn_off(self):
        # Code to turn off the light

In this example, the LightSwitch class depends on the Light class to turn the light on and off. However, this violates the DIP, since the LightSwitch is a high-level module and Light is a low-level module.

To fix this, we can invert the dependency by introducing abstraction.

from abc import ABC, abstractmethod

class Switchable(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class LightSwitch:
    def __init__(self, switchable):
        self.switchable = switchable

    def turn_on(self):
        self.switchable.turn_on()

    def turn_off(self):
        self.switchable.turn_off()

class Light(Switchable):
    def turn_on(self):
        # Code to turn on the light

    def turn_off(self):
        # Code to turn off the light

Now, the 'LightSwitch' class relies on the 'Switchable' interface rather than the 'Light' class directly. This ensures that the high-level module ('LightSwitch') depends on an abstraction('Switchable'), rather than low-level module('Light') directly.

References:

Object Oriented Programming in Python

AJITH D R — Thu, 16 Feb 2023 06:48:16 +0000

What is Object Oriented Programming?

Object-oriented programming(OOP) is a way of writing computer programs that revolves around the concept of objects. An object is a combination of data and the functions that operate on that data.

For instance, an object could represent a person with attributes like a name, age, emailId, address and behaviors like walking, breathing, talking and running.

By using OOP, we can create modular, reusable code that is easier to maintain and extend.

How to define a Class:

The beginning of a class definition requires the use of the "class" keyword followed by the class name and a colon. Any code that is inside the indented block of this class definition is considered to be a part of the class's body.

Here's an example of Person class.

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

The _init_() method is a special method that gets called when a new instance of the class is created, and here it sets the initial values for the name and age attributes.
'self' is a reference to the instance of the class that is being created when the _init_ method is called.

To create an instance of the 'Person' class, you can simply call a function and pass in the necessary arguments:

person = Person('Alice', 25)

This will create a new Person object with the name "Alice" and age 25.

Class and Instance Attributes:

In Python, a class attribute is a variable that is associated with a class, whereas an instance attribute is a variable that is associated with an instance of the class. Here are some examples of how to define and use class and instance attributes in Python:

class Person:
    species = "human"

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

In this example,

'species' is a class attribute of the Person class, which is associated with the class itself, not with any particular instance of the class.
The value of species is shared by all instances of the Person class.
We can access the class attribute using the class name and instance attributes using the instance variable.

print(Person.species)  # "human"

person = Person("Alice", 25)
print(person.name) # "Alice"
print(person.age) # 25

Types of methods

Instance Methods: Instance methods are the most common type of method in Python. They are associated with an instance of the class and can access and modify the instance's state.
Class Methods: Class methods are bound to the class rather than the instance. They can be used to modify the class state or perform operations that are not specific to any instance of the class.
Static Methods: Static methods do not depend on the class or instance state. They are often used for utility functions that do not modify the class or instance state

class Person:
    num_people = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.num_people += 1

    def say_hello(self):
        print(f"Hello, my name is {self.name}.")

    @classmethod
    def num_instances(cls):
        print(f"{cls.num_people} People instances are created.")

    @staticmethod
    def is_adult(age):
        return age >= 18

In this example,

The class variable 'num_people' keeps track of the total number of Person objects that have been created.
The _init_() method sets the name and age attributes for each Person object and increments the num_people class variable.
The say_hello() method is an instance method that prints a message that includes the person's name.
The num_instances() method is a class method that prints the total number of Person objects that have been created.
The is_adult() method is a static method that takes an age argument and returns a Boolean value indicating whether the person is an adult.

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

person1.say_hello()  # Output: "Hello, my name is Alice."
person2.say_hello()  # Output: "Hello, my name is Bob."

Person.num_instances()  # Output: "2 People instances are created."

print(Person.is_adult(person1.age))  # Output: True
print(Person.is_adult(person2.age))  # Output: True
print(Person.is_adult(16))  # Output: False

Inheritance:

Inheritance allows one class to inherit properties and methods from another class. In Python, we can create a subclass by specifying the parent class in parentheses after the subclass name.

Types of Inheritance:

Single inheritance: A subclass inherits from superclass.

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

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

student = Student("Alice", 20, "12345")

print(student.name)        # Output: Alice
print(student.age)         # Output: 20
print(student.student_id)  # Output: 12345

In this example, the Student class inherits from the Person class, so it gets access to the name and age attributes defined in the Person class.

Multiple inheritance: A subclass inherits from multiple superclasses.

class A:
    def dothis(self):
        print('do this in A')

class B(A):
    pass

class C:
    def dothis(self):
        print('do this in C')

class D(B, C):
    pass

d_instance = D()
d_instance.dothis()  #do this in A

In this example, the 'D' class inherits both the 'B' and 'C' classes, allowing it to access their attributes and methods.

Multilevel inheritance: A subclass inherits from a superclass, which inherits from another superclass.

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

class Parent(Grandparent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

class Child(Parent):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

child = Child("Alice", 25, "A")
print(child.name)  # Alice
print(child.age)   # 25
print(child.grade) # A

Here, the Child class inherits from the Parent class, which in inherits from the Grandparent class.

Hierarchical inheritance: Multiple subclasses inherit from a single superclass.

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

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

Here, both the Teacher and Principal classes inherit from the Person class.

Hybrid inheritance: A combination of two or more types of inheritance.

class A:
    def method(self):
        print("Method of class A")

class B(A):
    pass

class C(A):
    def method(self):
        print("Method of class C")

class D(B, C):
    pass

Here, the D class uses multiple inheritance to inherit from both the B and C classes, which in turn inherit from the A class.

Encapsulation:

It is a mechanism that allows us to restrict access to an object's data and methods. When a class member is marked as private, it can only be accessed from within the class. A member can be marked as private by prefixing its name with two underscores.

class Book:
    def __init__(self, title, author, price):
        self.title = title
        self.author = author
        self.price = price
        self.__discount = 0.10

book1 = Book('Book 1', 12, 'Author 1', 120)

print(book1.title)     # Book 1
print(book1.author)    # Author 1
print(book1.price)     # 120
print(book1.__discount)# AttributeError: 'Book' object has no attribute '__discount'

We cannot access the '__discount' attribute as it is a private attribute. To access private attributes, we use getter and setter methods.

class Book:
    def __init__(self, title, author, price):
        self.title = title
        self.author = author
        self.price = price
        self.__discount = None

    def set_discount(self, discount):
        self.__discount = discount

    def get_discount(self)
        return self.__discount

book = Book('Book 1', 'Author 1', 200)
book.set_discount(0.10)
print(book.get_discount())    # 0.10

Polymorphism:

Polymorphism refers to having many forms. In OOP, it refers to the functions having same names but does different things.

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

    def eat(self):
        print('eating')

class Dog(Animal):
    def show_affection(self):
        print(f'{self.name} wags tail')

class Cat(Animal):
    def show_affection(self):
        print(f'{self.name} purrs')


dog = Dog('Rover')
cat = Cat('Fluffy')

dog.show_affection() # Rover wags tail
cat.show_affection() # Fluffy purrs

Data Abstraction:

Data Abstraction allows us to hide the internal implementations of a function and expose only its functionalities.
To create an abstraction class, first, we need to import the ABC class from abc module. ABC is an acronym for Abstract Base Class.

from abc import ABC, abstractmethod

class Vehicle(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def info(self):
        pass

vehicle = Vehicle("Honda") # TypeError: Can't instantiate abstract class Car with abstract method info

The reason we get the TypeError is we have not implemented the abstract method. Abstract methods are implemented in the child classes.

class Car(Vehicle):
    def info(self):
        print(f"{self.name} information")

car = Car("Honda")
car.info()    # Honda information.

References:

Python String Methods

AJITH D R — Wed, 15 Feb 2023 12:53:07 +0000

1.format():
The format() method is used to insert values into a string. It takes a string as a template and replaces any placeholders with the corresponding values.
Example:

str = "I am {} {} method."
print(str.format("learning", "format()"))
#Output: I am learning format() method.

2.capitalize():
The capitalize() method is used to convert the first character of a string to uppercase, and all other characters to lowercase.
Example:

string = 'python Language'
print(string.capitalize()) #Output: 'Python language'

The above line does not change the original string. To modify the original string, we should assign it to the original string variable.

3.upper():
The upper() method is used to convert all the characters in a string to uppercase.

string = 'python'
string = string.upper()
print(string) #Output: 'PYTHON'

We can use isupper() method on a string to check if all the characters in a string are in upper-case.

4.lower():
The lower() method is used to convert all the characters in a string to lowercase.

string = 'Python'
print(string.lower()) #Output: 'python'

We can use islower() method on a string to check if all the characters in a string are in lower-case.

5.strip():
The strip() method removes any leading and trailing spaces from a string.

string = '    python    '
print(string.strip()) #Output: 'python'

There are also lstrip() and rstrip() methods to strip only the left-end spaces and right-end spaces.

6.join():
The join() method is used to join all the string values inside a list with a specified separator.

list_of_strings = ['abc','def','ghi']
print(''.join(list_of_strings)) #Output: abcdefghi

print(', '.join(list_of_strings)) #Output: abc, def, ghi

7.isalnum():
The isalnum() method takes a string as an argument and returns True if all the characters in that string are alpanumeric, otherwise returns False.

string = 'Python3'
print(string.isalnum()) #True

string = 'Python&3'
print(string.isalnum()) #False

8.isalpha():
The isalpha() method takes a string as an argument and returns True if all the characters in that string are alpabets, otherwise returns False.

string = 'Python'
print(string.isalpha()) #True

string = 'Python3'
print(string.isalpha()) #False

9.isdigit():
The isdigit() method takes a string as an argument and returns True if all the characters in that string are digits, otherwise returns False.

string = '123'
print(string.isdigit()) #True

string = 'python'
print(string.isdigit()) #False

10.split():
The split() method is used to convert a string to a list of strings by splitting up the string at the specified separator.

languages = 'Python,Java,JavaScript'
print(languages.split(',')) # ['Python', 'Java', 'JavaScript']

11.startswith():
The startswith() method is used to check whether a string starts with specified prefix or not. It returns True if the string starts with the specified string.

string = 'Python language'
print(string.startswith('Pyth')) # True

string = 'Python language'
print(string.startswith('pyth    ')) # False

12.endswith():
The endswith() method is used to check whether a string ends with specified suffix or not. It returns True if the string ends with the specified string.

string = 'Python language'
print(string.endswith('uage')) # True

13.replace():
The replace() method is used to replace every occurrence of matching substring with another string.

line = 'Python is a snake'
line = line.replace('snake', 'language') #Python is a language

14.index():
The index() method returns the index of first occurrence of the given substring. If the given substring is not in the string, then it raises an exception.
We can also give start and end index in which we want to find the substring.

line = 'Hello world'
print(line.index('world')) #6

print(line.index('hello')) #ValueError: substring not found

print(line.index('o', 6, 10)) #7

15.find():
The find() method is same as index() method. But, it returns -1 when substring is not found.

line = 'Hello world'
print(line.index('world')) #6

print(line.index('hello')) #-1

References:

Python List Methods

AJITH D R — Wed, 15 Feb 2023 12:52:46 +0000

1.append():
The append() method is used to append a value at the end of an existing list. The value to be appended is passed as an argument.

arr = []
arr.append(1)
print(arr) #[1]

2.insert():
The insert() method is used to add an element to a list at the specified position. All the elements from the specified position will be shifted to the right. If the given position is out of range, the element will be appended at the end.

print(arr) #[1]
arr.insert(0, 10)
print(arr) #[10, 1]

3.extend():
The extend() method takes a list of values as an argument and adds all the values to the existing list.

print(arr) #[10, 1]
arr.extend([2, 3, 4])
print(arr) #[10, 1, 2, 3, 4]

4.remove():
The remove() method removes the given element from the list. If there are duplicate elements, the first occurrence will be removed, and if the given element is not in the list, exception will be raised.

print(arr) [10, 1, 2, 3, 4]
arr.remove(10)
print(arr) [1, 2, 3, 4]
arr.remove(12) #ValueError: list.remove(x): x not in list

5.pop():
The pop() method is used to remove an element at a specified index from the list. If the index position is not given, last element will be removed.

print(arr) #[1, 2, 3, 4]
arr.pop(2)
print(arr) #[1, 2, 4]
arr.pop()
print(arr) #[1, 2]
arr.pop(4) #IndexError: pop index out of range

6.index():
The index() method takes a value as an argument and returns the index of first occurrence position of that value. If the value is not in the list, an exception will be raised.

print(arr) #[1, 2]
print(arr.index(2)) #1
print(arr.index(3)) #ValueError: list.index(x): x not in list

7.count():
The count() method takes a value as an argument, searches the value in the list and returns the number of times the value has repeated in the list.

print(arr) #[1, 2]
print(arr.count(2)) #1
arr.extend([2, 3, 4, 5])
print(arr.count(2)) #2

8.reverse():
This method reverses the list and returns the reversed list as an output.

print(arr) #[1, 2, 2, 3, 4, 5]
arr.reverse()
print(arr) #[5, 4, 3, 2, 2, 1]

9.sort():
This method sorts the list list in-place in ascending or descending order. By default, this method sorts the list in ascending order. To sort the list in the descending order we should set reverse to True in the argument.

print(arr) #[5, 4, 3, 2, 2, 1]
arr.sort()
print(arr) #[1, 2, 2, 3, 4, 5]
arr.sort(reverse=True)
print(arr) #[5, 4, 3, 2, 2, 1]

10.copy():
This methods returns a copy of the list.

print(arr) #[5, 4, 3, 2, 2, 1]
arr2 = arr.copy()
print(arr2) #[5, 4, 3, 2, 2, 1]

11.clear():
This method is used to remove all the values inside a list.

print(arr) #[5, 4, 3, 2, 2, 1]
arr.clear()
print(arr) #[]

References:

Introduction to Basic Linux Commands

AJITH D R — Thu, 02 Feb 2023 04:27:24 +0000

In this post, I will be sharing some basic information about Linux commands, which are essential tool to interact with the Linux operating system.

As you may know, Linux is an open-source operating system based on Unix. One of the primary ways to interact with Linux is through the terminal, which is a command-line interface.

You can perform various tasks in the terminal using commands. Here I will be explaining 5 commands:

mkdir
cd
mv
cp
man

mkdir(make directory)

mkdir is a command in Unix-based systems used to create a new directory.
Examples of using the mkdir command:

To create a new directory called newdir in the current directory:

mkdir newdir

To create a new directory called folder inside the desktop directory:

mkdir ~/Desktop/folder

If you want to create a directory along with its parent directories in your home directory in one go:

mkdir -p newfolder/myFolder/private

This will create the private directory, and any necessary parent directories. The -p option allows us to create a directory hierarchy,creating any necessary parent directories along the way.

cd (change directory)

The cd is used to navigate the file system and change the current working directory.
Examples of using cd command:

If you want to go to your home directory:

cd ~

or you can just type cd and it will take you to your home directory.

cd

If you are in your Desktop directory and you want to go to the parent directory of your Desktop directory:

cd ..

The below command will take you to the specified directory.

cd <directory_name>

If you want to go to the root directory of the file system:

cd /

If you are in the directory /home/user/documents and you run the command cd /usr/bin, you can use the cd - command to go back to the previous directory, which is /home/user/documents.

cd -

Note that using cd - will only take you to the most recently visited directory. If you have navigated through multiple directories and want to return to an earlier directory, you will need to use cd in combination with the path to that directory.

There are other flags to use with cd command
- cd . : It does nothing but stay in your current working directory.
- cd ~ : It will take you to your home directory.

mv (move or rename)

The mv command is used to move or rename files or directories in your system.

Examples of using mv command:

Moving a file:

mv file.txt /path/to/destination/directory

This moves the file file.txt from its current location to the directory at /path/to/destination/directory.

Renaming a file:

mv file.txt file_new.txt

This renames the file file.txt to file_new.txt in the same directory.

Moving multiple files:

mv file1.txt file2.txt /path/to/destination/directory

This moves the files file1.txt and file2.txt from their current location to the directory at /path/to/destination/directory.

Moving a directory:

mv directory_name /path/to/destination/directory

This moves the directory directory_name and its contents to the directory at /path/to/destination/directory.

cp(copy)

The cp command is used to copy files and directories. Here are a few examples to illustrate how to use the cp command along with some flags:
Basic copy:

cp file.txt /path/to/destination/directory

This copies the file file.txt from its current location to the directory at /path/to/destination/directory

Copy directory recursively:

cp -R directory_name /path/to/destination/directory

This copies the directory directory_name and its contents recursively to the directory at /path/to/destination/directory

Overwrite existing files:

cp -f file.txt /path/to/destination/directory

This copies the file file.txt to the directory at /path/to/destination/directory and overwrites existing files in the destination directory if any.

man(manual)

It would be difficult to remember all the commands and its flags and options, especially if you are new to linux.
If you ever want to know all the information related a particular command, you can use man command.
The man command in Linux is short for manual and is used to display the manual pages of the specified command. * The manual pages provide a detailed description of the command, including its syntax, options, and usage examples.
All you have to do is type man and which command's details you want to know.

man ls

That is it for this post. I covered how to create a folder/directory, change to a directory, rename or move files/directories, copy files into directory and lastly if you ever stuck on a command make use of man command.