DEV Community: Ankit Kumar

Django Framework

Ankit Kumar — Thu, 15 Jun 2023 13:00:36 +0000

What is secret key?

The Django secret key is used to provide cryptographic signing. This key is mostly used to sign session cookies. If one were to have this key, they would be able to modify the cookies sent by the application.

How to create example:-
Go to python shell:-

 python manage.py shell
  from django.core.management.utils import
 get_random_secret_key

secret_key = get_random_secret_key()
print(secret_key) //output
e+qpb)x^mjtdbr!gc8@81+drn6gz*r)in=pu0=j8s7o3b@m9$z

MVT Architecture

In Django, the MVT (Model-View-Template) architecture is a design pattern that separates the components of an application to handle different responsibilities. Here's an overview of the MVT architecture in Django:

Model: The Model represents the data structure and handles the interactions with the database. It defines the data schema, relationships between different data entities, and provides methods for querying and manipulating the data. In Django, models are typically defined as Python classes that inherit from the django.db.models.Model class.
View: The View defines the logic behind handling and processing user requests. It receives requests from the user, interacts with the appropriate models to retrieve or manipulate data, and prepares the necessary data to be rendered by the template. In Django, views are Python functions or classes that receive HTTP requests and return HTTP responses.
Template: The Template represents the presentation layer and defines how the data should be rendered and displayed to the user. It uses HTML, along with Django's template language, to structure the content and dynamically insert data retrieved from the views. Templates can include variables, loops, conditionals, and other template tags to control the rendering process.
The flow of data in the MVT architecture follows this pattern: User Request -> URL Mapping -> View -> Model -> Template -> Response

Setting File

Inside the settings.py file in a Django project, you'll find various configurations and settings that define the behavior and functionality of the project.

Here are some key aspects commonly found in the settings.py file:

Debug mode: The DEBUG setting controls whether the project runs in debug mode or not. Debug mode provides detailed error messages and tracebacks for easier debugging during development.
Allowed hosts: The ALLOWED_HOSTS setting specifies the valid hosts/domain names that the Django project can serve. It is a security measure to prevent HTTP Host header attacks. You should specify the appropriate domain names or IP addresses here.
Database configuration: The DATABASES setting defines the configuration details for connecting to the project's database. It includes the database engine, name, host, port, username, password, and other relevant options. Django supports various database backends such as SQLite, MySQL, PostgreSQL, etc.
Installed apps: The INSTALLED_APPS setting lists the Django applications installed in the project. These apps may come with Django or be custom-built for the project. Django uses this setting to discover and include the necessary app-specific configurations and URLs.
Middleware: The MIDDLEWARE setting specifies a list of middleware classes that Django applies to each request/response cycle. Middleware components can perform various tasks like authentication, session management, CSRF protection, and more. You can customize the order and add/remove middleware based on project requirements.
Static and media files: The STATIC_URL, STATIC_ROOT, STATICFILES_DIRS, MEDIA_URL, and MEDIA_ROOT settings handle the configuration for serving and managing static files (e.g., CSS, JavaScript) and media files (e.g., user-uploaded images). These settings define the URLs, storage locations, and other related options.
Template configuration: The TEMPLATES setting defines the configuration for template rendering in the project. It includes options like template engines, template directories, context processors, and other template-related settings.
Internationalization and localization: The LANGUAGE_CODE and TIME_ZONE settings determine the default language and time zone for the project. Django supports multilingual websites and provides tools for internationalization (i18n) and localization (l10n).
Authentication and authorization: The AUTHENTICATION_BACKENDS, AUTH_USER_MODEL, and other related settings handle user authentication and authorization. They define the authentication backends, the custom user model (if any), password hashing algorithms, login/logout URLs, and more.
Logging: The LOGGING setting configures the logging behavior of the Django application. It defines loggers, handlers, formatters, and log levels to control how logs are captured, processed, and outputted.

Application File

In a Django project, application files are components that encapsulate specific functionality and can be reused across different projects. Each application typically has its own set of files and directories that work together to provide a specific feature or functionality within the project. Here's an overview of the main files commonly found in a Django application:

models.py: This file contains the definition of the application's data models using Django's Object-Relational Mapping (ORM) system. Models define the structure and behavior of database tables, allowing you to interact with data in a Pythonic way.
views.py: The views.py file contains the view functions or classes that handle HTTP requests and generate responses. Views receive requests, interact with models and other components, and render templates or return JSON/XML responses.
urls.py: The urls.py file defines the URL patterns or routes for the application. It maps specific URLs to corresponding view functions or classes, allowing you to specify how requests should be handled and which views should be invoked.
forms.py: This file contains Django forms that handle data validation and rendering HTML forms. Forms define the fields, validation rules, and behavior of input forms used in the application. They can simplify form handling and data processing.
admin.py: The admin.py file allows you to register models to be managed through Django's built-in administration interface. It lets you define how models are displayed, filtered, and edited in the admin interface, providing a convenient way to manage data.
tests.py: This file holds the test cases for the application. Django encourages writing automated tests to ensure the correctness and reliability of the application's functionality. Test cases can be created to validate models, views, forms, and other components.
apps.py: The apps.py file provides application-specific configuration. It allows you to define metadata for the application, specify application-level signals, and perform application-specific initialization tasks.
Template files: It is not recommended to write html code inside python script (views.py file) because:
1) It reduces readability because Python code mixed with html code
2) No seperation of roles. Python developer has to concentrate on both python code and
HTML Code.
3) It does not promote reusability of code
We can overcome these problems by seperating html code into a seperate html file.This
html file is nothing but template.
From the Python file (views.py file) we can use these templates based on our
requirement
Static files: Up to this just we injected normal text data into template by using template tags.
But sometimes our requirement is to insert static files like images,css files etc inside template file.
Migrations: As the application's data models evolve, Django uses migrations to manage changes to the database schema. Migration files are automatically created and stored in a migrations directory within each application. They track and apply database schema changes.

Project Files

settings.py: The main settings file in a Django project. It contains configuration options that apply to the entire project, such as database settings, middleware, installed apps, static and media file paths, and more.
urls.py: The URL configuration file that maps URL patterns to corresponding views. It determines how URLs are processed and which view function or class is invoked for a particular URL.
wsgi.py: The WSGI (Web Server Gateway Interface) file that acts as the entry point for the WSGI server to interact with the Django application. It sets up the Django application's environment and provides a callable application object.
manage.py: A command-line utility script used for various management tasks in a Django project. It allows you to run development server, create database tables, execute custom management commands, perform migrations, and more.

CSRF

CSRF stands for Cross-Site Request Forgery. It is a type of attack where an attacker tricks a user into performing unintended actions on a website without their knowledge or consent. The attack takes advantage of the trust between the user's browser and the target website, exploiting the fact that the browser automatically includes any relevant authentication cookies in requests to the website.

Here's how a CSRF attack typically works:

The attacker creates a malicious website or injects malicious code into a legitimate website.
The user visits the malicious website or the compromised legitimate website while authenticated to the target website.
The malicious website or code triggers a request to the target website on behalf of the user, using the user's authentication cookies.
The target website receives the forged request, assuming it originated from the authenticated user, and performs the unintended action.
The user's account or data on the target website may be compromised or modified without their knowledge.

To prevent CSRF attacks, web applications use CSRF protection mechanisms, with the most common method being the usage of CSRF tokens. CSRF tokens are random, unique tokens generated by the server and embedded in the web forms or requests of the application.

Here's how CSRF tokens work:

When the user loads a form or logs in, the server generates a CSRF token and associates it with the user's session.
The CSRF token is then embedded in the form as a hidden input field or included as a header in subsequent requests.
When the user submits the form or performs an action, the server verifies that the received CSRF token matches the one associated with the user's session.
If the CSRF token is valid and matches, the request is considered legitimate, and the action is performed. Otherwise, the request is rejected.

ORM

Django's ORM (Object-Relational Mapping) is a powerful feature that allows developers to interact with the database using Python code and objects, rather than writing raw SQL queries.

Here are commonly used methods and operations provided by Django's ORM:

objects.all(): Retrieve all objects of a model from the database.
objects.get(**kwargs): Retrieve a single object that matches the specified filter criteria.
objects.filter(**kwargs): Retrieve a QuerySet of objects that match the specified filter criteria.
objects.exclude(**kwargs): Exclude objects that match the specified filter criteria.
objects.create(**kwargs): Create a new object and save it to the database.
object.save(): Save changes to an existing object to the database.
object.delete(): Delete an object from the database.
objects.count(): Count the number of objects that match the specified filter criteria.
objects.order_by(*fields): Sort the QuerySet by one or more fields.
objects.values(*fields): Retrieve a QuerySet of dictionaries containing specific fields' values.
objects.annotate(*args, **kwargs): Perform aggregations or annotate additional fields in the QuerySet.
object.field: Access a specific field value of an object.
objects.distinct(): Return a QuerySet with unique results.
objects.exists(): Check if at least one object exists that matches the specified filter criteria.
objects.update(**kwargs): Update one or more fields of multiple objects in a single database query.
objects.bulk_create(obj_list): Create multiple objects in a single database query.
objects.select_related(*fields): Retrieve related objects in a single database query to optimize performance.
objects.defer(*fields): Delay loading of specified fields until they are accessed.
objects.only(*fields): Restrict the fields retrieved from the database to improve performance.
objects.values_list(*fields): Retrieve a QuerySet of tuples containing specific fields' values. Examples:-

    # Import necessary Django modules
    import os
    import django

    # Set up Django environment
    os.environ.setdefault('DJANGO_SETTINGS_MODULE',  'your_project.settings')
    django.setup()

    # Import your Django models
    from your_app.models import Person

    # Create a new person
    person = Person(name='John Doe', age=30)
    person.save()

    # Retrieve all persons from the database
    persons = Person.objects.all()

    # Print the names and ages of all persons
    for person in persons:
        print(person.name, person.age)

    # Filter persons based on age
    persons_filtered = Person.objects.filter(age__gt=25)

    # Print the names and ages of filtered persons
    for person in persons_filtered:
        print(person.name, person.age)

    # Update a person's age
    person_to_update = Person.objects.get(name='John Doe')
    person_to_update.age = 35
    person_to_update.save()

    # Delete a person
    person_to_delete = Person.objects.get(name='John Doe')
    person_to_delete.delete()

References

GFG
DOCUMENTATIONS

JS Asynchronous-Technical Paper

Ankit Kumar — Thu, 01 Jun 2023 09:17:51 +0000

Callbacks

a callback function is a function that is passed as an argument to another function and is intended to be called later, often after an asynchronous operation or a certain event occurs. Callbacks are a fundamental concept in JavaScript for handling asynchronous code execution.
Example:-

function fetchData(callback) {
  setTimeout(() => {
    const data = 'Sample data';
    callback(data);
  }, 2000);
}

function processData(data) {
  console.log('Processing data:', data);
}

console.log('Start');
fetchData(processData);
console.log('End');

Promises

Promises are a feature introduced in ECMAScript 2015 (ES6) that provide a more structured and readable way to handle asynchronous operations in JavaScript. Promises represent the eventual completion (or failure) of an asynchronous operation and allow you to chain multiple asynchronous operations together.
Example:-

    function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const data = 'Sample data';
      resolve(data); // Resolving the promise with the fetched data
      // If there's an error, you can reject the promise instead:
      // reject(new Error('Failed to fetch data'));
    }, 2000);
  });
}

function processData(data) {
  console.log('Processing data:', data);
}

console.log('Start');
fetchData()
  .then(processData)
  .catch(error => {
    console.error('Error:', error.message);
  })
  .finally(() => {
    console.log('Cleanup');
  });
console.log('End');

Here's how the execution flows:

"Start" is logged to the console.
The fetchData function is called, and a new Promise is created.
The asynchronous operation starts with a timer set for 2000 milliseconds.
"End" is logged to the console.
After 2000 milliseconds, the timer expires, and the promise is resolved with the fetched data.
The then method is called on the promise, and the processData function is passed as the callback.
The processData function is called with the fetched data.
"Processing data: Sample data" is logged to the console.
The finally method is called, and "Cleanup" is logged to the console.

Code Control

the event loop plays a crucial role in managing the control flow of asynchronous code execution. It ensures that tasks, including callbacks and events, are executed in a specific order while keeping the JavaScript runtime single-threaded.
The event loop follows a cycle that consists of the following phases:

Handle Synchronous Code: The event loop starts by executing any synchronous code present in the call stack. This includes executing functions, operations, and statements that are not asynchronous.
Handle Asynchronous Operations: After the synchronous code is executed, the event loop checks if there are any asynchronous operations that have completed.

If there are completed asynchronous operations, their associated callbacks or promises are added to the callback queue or microtask queue (depending on the type of task).
The callbacks or promises in the queues are not executed immediately; they are waiting for the call stack to be empty.

Event Loop Iteration: If the call stack is empty, the event loop starts iterating to handle the callbacks and promises waiting in the queues.

The event loop checks the microtask queue first. Microtasks generally include promise callbacks, mutation observers, or other high-priority tasks. It processes all the microtasks present in the queue until it is empty.
After processing all the microtasks, the event loop moves to the callback queue and starts executing the callbacks. These could be timer callbacks, event handlers, or other lower-priority tasks. It takes one callback from the queue and executes it.
The event loop repeats this process, continuously checking and executing tasks from the microtask queue and the callback queue in an alternating manner.

References

W3SCHOOL
GFG

JAVASCRIPT Technical Paper

Ankit Kumar — Mon, 29 May 2023 10:59:40 +0000

JavaScript is a high-level, interpreted programming language primarily used for creating dynamic and interactive web pages.

Loop

for :- The for loop is a traditional loop structure that repeats a block of code a specific number of times. It consists of three parts: initialization, condition, and increment/decrement.
example:-
```
for (let i = 0; i < 5; i++) {
  console.log(i);
}
```
forEach :- The forEach loop is a method available on arrays that iterates over each element and executes a callback function for each element.
example:-
```
const numbers = [1, 2, 3, 4, 5];
numbers.forEach(function(number) {
  console.log(number);
});
```
for..in :- The for...in loop iterates over the properties of an object. It allows you to loop through the enumerable properties of an object.
example:-
```
const person = {
name: "John",
age: 30,
city: "New York"
};
for (let key in person) {
  console.log(key + ": " + person[key]);
}
```
for..of :- The for...of loop iterates over iterable objects, such as arrays or strings. It allows you to loop through each element of the iterable.
example:-
```
const colors = ["red", "green", "blue"];
for (let color of colors) {
  console.log(color);
}
```
while :- The while loop executes a block of code repeatedly as long as a specified condition is true. It does not require an explicit counter.

example:-

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

Mutable and Immutable Methods (in strings and arrays)

Mutable methods modify the original string or array. Immutable methods return a new string or array, leaving the original unchanged.

Strings:
Mutable Methods:
- concat: Concatenates two or more strings and returns a new string.
- slice: Extracts a portion of the string and returns a new string.
- replace: Replaces specified substring(s) with a new substring and returns a new string.
- toUpperCase and toLowerCase: Converts the case of the string and returns a new string.
- trim and other trimming methods: Removes whitespace characters from the string and returns a new string.
Immutable Methods:
- charAt and charCodeAt: Accesses a character or its Unicode value at a specified index.
- substring and substr: Extracts a substring from the original string.
- indexOf and lastIndexOf: Searches for a substring within the string and returns its index.
Array
Mutable Methods:
- push and pop: Add and remove elements from the end of an array.
- shift and unshift: Add and remove elements from the beginning of an array.
- splice: Modifies an array by adding, removing, or replacing elements at specified positions.
- reverse: Reverses the order of elements in an array.
- sort: Sorts the elements of an array in place.
Immutable Methods:
- concat: Concatenates two or more arrays and returns a new array.
- slice: Extracts a portion of an array and returns a new array.
- filter: Creates a new array with elements that satisfy a filtering condition.
- map: Creates a new array by applying a transformation function to each element.

Pass by Reference and Pass by Value

It provides an in-depth analysis of how JavaScript handles variable assignment and function parameter passing.

Pass by Value:
In pass by value, a copy of the value is passed to a function or assigned to a new variable.
Changes made to the copied value do not affect the original value.
Primitive data types (numbers, booleans, strings) are passed by value in JavaScript.

Example:

let num = 10;

function increment(num) {
  num += 1;
  console.log(num); // Output: 11
}

increment(num);
console.log(num); // Output: 10

Pass by Reference:
In pass by reference, a reference to the original value is passed to a function or assigned to a new variable.
Changes made to the referenced value affect the original value.
Objects and arrays are passed by reference in JavaScript.

Example:

    let arr = [1, 2, 3];

function modifyArray(arr) {
  arr.push(4);
  console.log(arr); // Output: [1, 2, 3, 4]
}

modifyArray(arr);
console.log(arr); // Output: [1, 2, 3, 4]

Array Methods:

Basics

Array.pop

The pop method removes the last element from an array and returns that element.

const fruits = ["apple", "banana", "orange"];
const removedFruit = fruits.pop();
console.log(fruits); // Output: ["apple", "banana"]
console.log(removedFruit); // Output: "orange"

Array.push

The push method adds one or more elements to the end of an array and returns the new length of the array.

    const fruits = ["apple", "banana"];
    const newLength = fruits.push("orange", "grape");
    console.log(fruits); // Output: ["apple", "banana",   "orange", "grape"]
    console.log(newLength); // Output: 4

Array.concat

The concat method combines two or more arrays and returns a new array.

const arr1 = [1, 2, 3];
const arr2 = [4, 5];
const combinedArray = arr1.concat(arr2);
console.log(combinedArray); // Output: [1, 2, 3, 4, 5]

Array.slice

The slice method extracts a portion of an array into a new array.

const numbers = [1, 2, 3, 4, 5];
const slicedArray = numbers.slice(1, 4);
console.log(slicedArray); // Output: [2, 3, 4]

Array.splice

The splice method changes the content of an array by removing, replacing, or adding elements.

const numbers = [1, 2, 3, 4, 5];
const removedElements = numbers.splice(2, 2, 6, 7);
console.log(numbers); // Output: [1, 2, 6, 7, 5]
console.log(removedElements); // Output: [3, 4]

Array.join

The join method combines all elements of an array into a string.

const fruits = ["apple", "banana", "orange"];
const joinedString = fruits.join(", ");
console.log(joinedString); // Output: "apple, banana, orange"

Array.flat

The flat method creates a new array with all sub-array elements concatenated recursively up to the specified depth.

const nestedArray = [1, 2, [3, 4, [5, 6]]];
const flattenedArray = nestedArray.flat(2);
console.log(flattenedArray); // Output: [1, 2, 3, 4, 5,]

Findings
- Array.find:
  
  The find method returns the first element in an array that satisfies a provided testing function.If a matching element is found, find returns the element itself; otherwise, it returns undefined.
  Example:
```
`   const numbers = [1, 2, 3, 4, 5];
const foundNumber = numbers.find((num) => num > 3);
console.log(foundNumber); // Output: 4` 
```
- Array.indexOf:
  
  The indexOf method returns the first index at which a specified element is found in an array.
  If the element is not found, it returns -1.
  Example:
```
const fruits = ["apple", "banana", "orange"];
const index = fruits.indexOf("banana");
console.log(index); // Output: 1` 
```
- Array.includes:
  
  The includes method determines whether an array includes a certain element, returning a boolean value.
  Example:
```
`const numbers = [1, 2, 3, 4, 5];
const includesThree = numbers.includes(3);
console.log(includesThree); // Output: true` 
```
- Array.findIndex:
  
  The findIndex method returns the index of the first element in an array that satisfies a provided testing function.
  Example:
```
    `const numbers = [1, 2, 3, 4, 5];
    const index = numbers.findIndex((num) => num > 3);
    console.log(index); // Output: 3` 
    ```
```

Higher Order Function

Array.forEach:

The forEach method executes a provided callback function once for each element in an array.
The callback function takes three arguments: the current element, the index, and the array itself.
Example:

`const numbers = [1, 2, 3, 4, 5];
numbers.forEach((num) => {
  console.log(num * 2);
});
// Output:
// 2
// 4
// 6
// 8
// 10`

Array.filter:

The filter method creates a new array with all elements that pass a provided filtering function.
The filtering function takes three arguments: the current element, the index, and the array itself.
Example:
```
      `const numbers = [1, 2, 3, 4, 5];
    const evenNumbers = numbers.filter((num) => num % 2 ===  0);
    console.log(evenNumbers); // Output: [2, 4]` 
```
Array.map:

The map method creates a new array with the results of calling a provided function on every element in the array.
The mapping function takes three arguments: the current element, the index, and the array itself.
Example:
```
`const numbers = [1, 2, 3, 4, 5];
const doubledNumbers = numbers.map((num) => num * 2);
console.log(doubledNumbers); // Output: [2, 4, 6, 8, 10]` 
```
Array.reduce:

The reduce method applies a provided function to reduce the array to a single value.
The reducing function takes four arguments: the accumulator, the current element, the index, and the array itself.
Example:

    `const numbers = [1, 2, 3, 4, 5];
    const sum = numbers.reduce((accumulator, num) => accumulator + num, 0);
    console.log(sum); // Output: 15` 
    ```


- Array.sort:

     The `sort` method sorts the elements of an array in place and returns the sorted array.
  Example:


    ```
    `const fruits = ["banana", "apple", "orange"];
    fruits.sort();
    console.log(fruits); // Output: ["apple", "banana", "orange"]`
    ```

Advance

Array methods chaining

By chaining array methods, the output of one method becomes the input for the next method in the chain. This allows you to perform multiple operations on an array in a single statement.

const numbers = [1, 2, 3, 4, 5];

const result = numbers
  .filter(num => num % 2 === 0)  // Filter even numbers
  .map(num => num * 2)           // Double each number
  .reduce((sum, num) => sum + num, 0);  // Calculate the sum

console.log(result);  // 18

String Methods

Mutable Methods (Modify the original string):

concat: Concatenates one or more strings with the original string and returns a new string.
slice: Extracts a portion of the string into a new string based on the specified indices.
splice: Changes the content of the string by adding, removing, or replacing characters.
replaceAll: Replaces all occurrences of a specified substring with another substring.
toUpperCase: Converts the string to uppercase characters.

toLowerCase: Converts the string to lowercase characters.
Example:-

let char = str.charAt(0);
console.log(char); // Output: "H"

let substring = str.substring(0, 5);
console.log(substring); // Output: "Hello"

let replacedFirstOccurrence = str.replace("o", "x");
console.log(replacedFirstOccurrence); // Output: "Hxllo World"

let splittedArray = str.split(" ");
console.log(splittedArray); // Output: ["Hello", "World"]

let trimmedStr = str.trim();
console.log(trimmedStr); // Output: "Hello World"

let startsWithHello = str.startsWith("Hello");
console.log(startsWithHello); // Output: true

let endsWithWorld = str.endsWith("World");
console.log(endsWithWorld); // Output: true

Immutable Methods (Create a new string without modifying the original string):

charAt: Returns the character at a specified index in the string.
substring: Extracts a portion of the string into a new string based on the specified indices.
replace: Replaces the first occurrence of a specified substring with another substring.
split: Splits the string into an array of substrings based on a specified delimiter.
trim: Removes whitespace from both ends of the string.
startsWith: Checks if the string starts with a specified substring.

endsWith: Checks if the string ends with a specified substring.
Example:-

let char = str.charAt(0);
console.log(char); // Output: "H"

let substring = str.substring(0, 5);
console.log(substring); // Output: "Hello"

let replacedFirstOccurrence = str.replace("o", "x");
console.log(replacedFirstOccurrence); // Output: "Hxllo World"

let splittedArray = str.split(" ");
console.log(splittedArray); // Output: ["Hello", "World"]

let trimmedStr = str.trim();
console.log(trimmedStr); // Output: "Hello World"

let startsWithHello = str.startsWith("Hello");
console.log(startsWithHello); // Output: true

let endsWithWorld = str.endsWith("World");
console.log(endsWithWorld); // Output: true

Object Methods and Opertions

Adding or Modifying Key-Value Pairs:

object[key] = value: Assigns a value to a specific key in the object. If the key already exists, the value will be updated; otherwise, a new key-value pair will be added.
1. Accessing Values:
object[key]: Retrieves the value associated with a specific key from the object.

Checking for Key Existence:

key in object: Returns true if the object contains the specified key; otherwise, returns false.
- object.hasOwnProperty(key): Returns true if the object directly contains the specified key (ignores keys from the prototype chain); otherwise, returns false.
- Removing Key-Value Pairs:
delete object[key]: Removes the key-value pair associated with the specified key from the object.
1. Getting All Keys:
Object.keys(object): Returns an array containing all the keys of the object.
1. Getting All Values:
Object.values(object): Returns an array containing all the values of the object.
1. Getting Key-Value Pairs as Arrays:

Object.entries(object): Returns an array of key-value pairs, where each pair is represented as an array [key, value].
Example:-

```
const hashmap = {};

// Adding key-value pairs
hashmap["name"] = "John";
hashmap["age"] = 30;
hashmap["city"] = "New York";

// Accessing values
console.log(hashmap["name"]); // Output: John

// Checking for key existence
console.log("age" in hashmap); // Output: true
console.log(hashmap.hasOwnProperty("gender")); // Output: false

// Removing key-value pair
delete hashmap["city"];

// Getting all keys
const keys = Object.keys(hashmap);
console.log(keys); // Output: ['name', 'age']

// Getting all values
const values = Object.values(hashmap);
console.log(values); // Output: ['John', 30]

// Getting key-value pairs as arrays
const entries = Object.entries(hashmap);
console.log(entries); // Output: [['name', 'John'], ['age', 30]]

Hoisting

Hoisting is a mechanism in JavaScript that allows variable and function declarations to be moved to the top of their respective scopes during the compilation phase, before the code is executed.

Only function declarations and variable declarations using var are hoisted.

Variables declared with let and const are not hoisted.
Example:-

console.log(x); // Output: undefined
var x = 10;
console.log(x); // Output: 10

Scopes

Scopes in JavaScript determine the accessibility and visibility of variables, functions, and objects within your code. JavaScript has three main types of scopes:

Global Scope:

The global scope is the outermost scope in JavaScript.
Variables declared in the global scope are accessible throughout the entire codebase, including within functions and other scopes.

Example:

  ```
   var globalVariable = "I'm in the global scope";

function globalFunction() {
  console.log(globalVariable); // Output: "I'm in the           global scope"
}

globalFunction();` 
  ```

Function Scope:

Each function in JavaScript creates its own scope, known as the function scope.
Variables declared within a function are only accessible within that function and any nested functions.

Example:

  ```

    `function outerFunction() {
      var outerVariable = "I'm in the outer function";

      function innerFunction() {
        console.log(outerVariable); // Output: "I'm in the outer function"
      }

      innerFunction();
    }

    outerFunction();`
  ```

Block Scope (Introduced in ES6):

Block scope is created by curly braces ({}) in statements such as if, for, while, and let/const variable declarations.
Variables declared with let and const are block-scoped and are only accessible within the block where they are defined.

Example:

  ```
    `function blockScopeExample() {
      if (true) {
        let blockVariable = "I'm in the block scope";
        console.log(blockVariable); // Output: "I'm in the block scope"
      }

      console.log(blockVariable); // Output: ReferenceError: blockVariable is not defined
    }

    blockScopeExample();`
  ```

Closures

A closure is a function along with its preserved lexical environment.
Here are some key points about closures:

Definition:

A closure is created when a nested function (inner function) accesses variables from its outer function, even after the outer function has completed execution.
The inner function "closes over" the variables it references, hence the term "closure".
1. Lexical Scope:
Closures rely on lexical scoping, which means that functions are executed using the variable scope they were defined in.
The inner function has access to the variables in its own scope, the scope of the outer function, and the global scope.
1. Preserved Environment:
Closures preserve the variables and their values at the time of creation, allowing the inner function to access and manipulate them even outside of the original scope.

This allows for data encapsulation and private variables in JavaScript.
Examples

    function outerFunction() {
      var outerVariable = 'I am from the outer function';

      function innerFunction() {
        console.log(outerVariable); // Accesses outerVariable from the outer function's scope
      }

      return innerFunction;
        }

        var closure = outerFunction(); // Assigns the inner function to the closure variable
        closure(); // Invokes the inner function, which logs "I am from the outer function"

Higher Order Functions

Higher-order functions can accept other functions as parameters.
The passed function is often referred to as a "callback" function.
This allows for the implementation of customizable behavior or logic.

Example:

function higherOrder(callback) {
  callback();
}

function callbackFunction() {
  console.log("I'm a callback function");
}

higherOrder(callbackFunction); // Outputs: "I'm a callback function"

References

GFG
W3SCHOOL

HTML - CSS Technical Paper

Ankit Kumar — Thu, 25 May 2023 07:16:13 +0000

Box Model

Box Model Structure
- The four components: content, padding, border, and margin
- Hierarchical arrangement and relationships between the components
Box Sizing Property
- Default value: content-box vs. alternative value: border-box
- Impact on element sizing and available space
Content Area
- Actual content and its dimensions within the box
- Affected by padding, border, and box sizing property
Padding
- Space between the content and the border
- Control over padding dimensions and individual sides
Border
- Visual boundary surrounding the content and padding
- Customizable properties like width, style, and color
Margin
- Space outside the border, creating gaps between elements
- Control over margin dimensions and collapsing margins
Box Model and Layout
- Impact on element positioning and flow within the document
- Understanding the total space occupied by an element
Box Model Adjustments
- Overriding default box model behavior using CSS properties
- Fine-tuning box dimensions and spacing

Inline vs Block elements

Differences

Box Model and Inline Elements

-   Inline elements occupy space only around their content
-   Lack of explicit dimensions like width and height

Box Model and Block Elements

-   Block elements occupy the full width of their parent container by default
-   Ability to specify dimensions using width and height properties

Inline elements
<span>: A generic inline container used for styling or manipulating specific sections of text.
<a>: Represents an anchor or hyperlink, allowing users to navigate to another page or location.
<em>: Emphasizes or highlights text by rendering it in italicized format.
<strong>: Indicates strong importance, rendering the text in bold.

<p>
My mother has  
<span style="color:blue;font-weight:bold;">blue</span>  
eyes and my father has  <span style="color:darkolivegreen;font-weight:bold;">dark green</span>  eyes.
</p>

Block elements
<div>: A generic block-level container used for grouping and structuring content.
<p>: Represents a paragraph of text, typically with a line break before and after.
<h1> to <h6>: Heading elements used to define different levels of headings, with <h1> being the highest level.
<ul>: Unordered list, displaying a list of items without any particular order.
<ol>: Ordered list, displaying a numbered or ordered list of items.
<li>: List item element used within <ul> or <ol> to represent individual items.
<table>: Creates a table for displaying tabular data, including rows and columns.
<form>: Represents an interactive form, containing input fields, checkboxes, buttons, etc.
<section>: Defines a section within a document, often used for grouping related content.
<header>: Represents the introductory content or a container for heading elements.
<footer>: Represents the footer or the closing content of a document or section. example:-

<div style="background-color:black;color:white;padding:20px;">  
<h2>London</h2>  
<p>
London is the capital city of England. It is the most populous city in the United Kingdom, with a metropolitan area of over 13 million inhabitants.
</p>  
</div>

Common CSS structural classes

CSS structural classes for targeting child elements allow you to apply specific styles to elements that are direct children of a particular parent element.

.parent .child: Selects any descendant element with the class "child" within a parent element, regardless of its level of nesting.
.parent:first-child: Selects the first child element within a parent element.
.parent:last-child: Selects the last child element within a parent element.
.parent:nth-child(n): Selects the nth child element within a parent element, where "n" can be a specific number, a keyword (e.g., "even" or "odd"), or a formula.
.parent:first-of-type: Selects the first element of a specific type within a parent element.
.parent:last-of-type: Selects the last element of a specific type within a parent element.
.parent:nth-of-type(n): Selects the nth element of a specific type within a parent element, using the same options as :nth-child.
.parent:first-child:nth-last-child(2): Selects the second-to-last child element within a parent element when it is also the first child.
.parent:only-child: Selects a child element that is the only child of its parent.

Common CSS syling classes

CSS styling classes are used to apply specific styles to HTML elements by assigning class names to those elements.

.text-center: Centers the text within an element horizontally.
.text-left: Aligns the text to the left within an element.
.text-right: Aligns the text to the right within an element.
.text-justify: Justifies the text within an element, creating equal spacing between words.
.text-uppercase: Converts the text to uppercase.
.text-lowercase: Converts the text to lowercase.
.text-capitalize: Capitalizes the first letter of each word in the text.
.bg-color: Sets the background color of an element.
.text-color: Sets the text color of an element.
.font-size: Sets the font size of the text within an element.
.font-family: Specifies the font family to be used for the text within an element.
.font-weight: Sets the font weight (e.g., bold or normal) of the text.
.font-style: Applies italic or normal style to the text.
.border: Adds a border around an element.
.padding: Sets the padding (spacing) within an element.
.margin: Sets the margin (spacing) around an element.
.display-block: Sets the display property of an element to block, making it occupy its own line.
.display-inline: Sets the display property of an element to inline, allowing it to flow with surrounding text.
.display-inline-block: Sets the display property of an element to inline-block, combining features of both block and inline elements.
.hidden: Hides the element by setting its display property to none.

CSS Specificity

CSS specificity determines which styles are applied to HTML elements when conflicting styles exist.

Inline Styles:

-   Highest specificity.
-   Applied directly to HTML elements using the `style` attribute.
-   Example: `<div style="color: red;">`

ID Selectors:

-   Second highest specificity.
-   Target elements using the `id` attribute.
-   Example: `#myElement { color: blue; }`

Class Selectors, Attribute Selectors, and Pseudo-Classes:

-   Lower specificity than IDs.
-   Target elements using class names, attributes, or pseudo-classes.
-   Example: `.myClass { color: green; }`

Type Selectors and Pseudo-Elements:

-   Lowest specificity.
-   Target elements based on their tag name or pseudo-elements.
-   Example: `div { color: yellow; }`

CSS Responsive Queries

CSS responsive queries, also known as media queries, allow developers to apply different styles based on the characteristics of the device or viewport. These queries enable the creation of responsive web designs that adapt to different screen sizes and devices.

Targeting Small Screens:

@media (max-width: 768px) {
  /* Styles for screens with a maximum width of 768px */
  /* Example: Mobile devices in portrait mode */
}

Targeting Medium Screens:

@media (min-width: 769px) and (max-width: 1024px) {
  /* Styles for screens with a width between 769px and 1024px */
  /* Example: Tablets in landscape mode */
}

Targeting Large Screens:

@media (min-width: 1025px) {
  /* Styles for screens with a minimum width of 1025px */
  /* Example: Desktop monitors or large screens */
}

Flexbox

CSS Flexbox is a layout module that provides a flexible way to arrange and align elements within a container.

Flex Container:

-   The parent element that contains flex items.
-   Use the `display: flex;` or `display: inline-flex;` property to create a flex container.

Flex Items:

-   The child elements of a flex container.
-   By default, flex items are laid out in a row (left to right).

Main Axis and Cross Axis:

-   Flexbox has two axes: the main axis and the cross axis.
-   The main axis is defined by the `flex-direction` property (default: row).
-   The cross axis is perpendicular to the main axis.

Flex Direction:

-   Determines the direction of the main axis.
-   Values: `row` (default), `row-reverse`, `column`, `column-reverse`.
-   Example: `flex-direction: column;`

Justify Content:

-   Aligns flex items along the main axis.
-   Values: `flex-start` (default), `flex-end`, `center`, `space-between`, `space-around`, `space-evenly`.
-   Example: `justify-content: center;`

Align Items:

-   Aligns flex items along the cross axis.
-   Values: `flex-start`, `flex-end`, `center`, `baseline`, `stretch` (default).
-   Example: `align-items: center;`

Align Self:

-   Overrides the `align-items` property for individual flex items.
-   Example: `align-self: flex-end;`

Flex Wrap:

-   Controls whether flex items should wrap onto multiple lines if they exceed the container's width.
-   Values: `nowrap` (default), `wrap`, `wrap-reverse`.
-   Example: `flex-wrap: wrap;`

Flex Grow, Flex Shrink, and Flex Basis:

-   Controls how flex items grow, shrink, and distribute space.
-   `flex-grow`: Specifies the flex grow factor.
-   `flex-shrink`: Specifies the flex shrink factor.
-   `flex-basis`: Specifies the initial size of the flex item.
-   Example: `flex: 1 0 200px;`

Flex Container Alignment:

-   Additional properties to align the flex container itself.
-   `align-content`: Aligns flex lines when there is extra space on the cross axis.
-   `align-self`: Aligns the flex container within its parent container.

Grid

CSS Grid is a powerful layout module that allows developers to create two-dimensional grid layouts for web pages. It provides a highly flexible and responsive way to arrange and align elements in rows and columns.

Grid Container:

-   The parent element that contains grid items.
-   Use the `display: grid;` property to create a grid container.

Grid Items:

-   The child elements of a grid container.
-   By default, grid items are automatically placed in the grid.

Grid Tracks:

-   The rows and columns that make up the grid.
-   Define the grid tracks using the `grid-template-rows` and `grid-template-columns` properties.

Grid Rows and Columns:

-   Specify the size of rows and columns using values like fixed lengths, percentages, or the `fr` unit (fractional unit).

Grid Gaps:

-   Create space between grid items using the `grid-gap` property.
-   Values: `grid-row-gap`, `grid-column-gap`, `grid-gap`.

Grid Placement:

-   Control the placement of grid items within the grid.
-   Use the `grid-row` and `grid-column` properties to specify the start and end positions of items.

Grid Areas:

-   Assign names to grid areas and reference them in the grid placement properties.
-   Define grid areas using the `grid-template-areas` property.

Grid Lines:

-   Horizontal and vertical lines that divide the grid into rows and columns.
-   Reference grid lines using numerical indices or named lines.

Grid Alignment:

-   Control the alignment of grid items within their cells.
-   Use the `justify-self` and `align-self` properties for horizontal and vertical alignment.

Grid Template:

-   Combine grid tracks, gaps, and areas into a single shorthand property.


  Use the grid-template property to define the grid template.

Common header meta tags

Header meta tags are HTML elements placed within the <head> section of a web page. They provide information about the webpage to search engines, browsers, and other web services.

<title>:

Specifies the title of the webpage.
- Example: <title>My Website</title>

<meta charset>:

Defines the character encoding for the webpage.
- Example: <meta charset="UTF-8">

<meta name="viewport">:

Controls how the webpage is displayed on different devices and screen sizes.
- Example: <meta name="viewport" content="width=device-width, initial-scale=1.0">

<meta name="description">:

Provides a brief description of the webpage's content.
- Example: <meta name="description" content="A website showcasing the latest fashion trends.">

<meta name="keywords">:

Specifies keywords related to the webpage's content.
- Example: <meta name="keywords" content="fashion, trends, clothing, style">

<meta name="author">:

Specifies the author of the webpage.
- Example: <meta name="author" content="John Doe">

<meta name="robots">:

Instructs search engine crawlers on how to index and display the webpage.
- Example: <meta name="robots" content="index, follow">

<link rel="canonical">:

Defines the canonical URL of a webpage to prevent duplicate content issues.
- Example: <link rel="canonical" href="https://www.example.com/page">

<link rel="stylesheet">:

Links an external CSS file to the webpage.
- Example: <link rel="stylesheet" href="styles.css">

<script>:

Embeds or references external JavaScript files.
- Example: <script src="script.js"></script>

Css Selectors

CSS selectors determine which HTML elements should be targeted and styled.

Element Selectors:

Select elements based on their tag names.
- Example: p { color: red; }

Class Selectors:

Select elements based on their class attribute.
- Example: .myClass { font-size: 16px; }

ID Selectors:

Select a single element based on its ID attribute.
- Example: #myElement { background-color: blue; }

Attribute Selectors:

Select elements based on their attributes.
- Example: input[type="text"] { border: 1px solid black; }

Pseudo-Classes:

Select elements based on their states or positions.
- Example: a:hover { color: purple; }

Pseudo-Elements:

Select and style a specific part of an element.
- Example: p::first-line { text-transform: uppercase; }

Combinators:

Combine multiple selectors to target specific elements.
- Example: ul li { list-style-type: square; }

Descendant Selectors:

Select elements that are descendants of another element.
- Example: div p { font-weight: bold; }

Child Selectors: Select elements that are direct children of another element.
- Example: ul > li { color: green; }
Universal Selectors: Select all elements in the document.
- Example: * { margin: 0; padding: 0; }

References

W3SCHOOLS
GFG

Listening and Active Communication

Ankit Kumar — Mon, 15 May 2023 18:17:58 +0000

Q 1. What are the steps/strategies to do Active Listening?

Active listening means fully focusing on the speaker without distractions to understand them better and respond appropriately. Here are some tips:

Stay engaged: Avoid getting distracted by your own thoughts and give your full attention to the speaker.
Note key points: Pay attention to important details shared by the speaker to improve your understanding. You can even jot down notes if it helps.
Show interest: Use body language maintaining an open posture to show that you are interested in what the speaker is saying.
Encourage sharing: Express your interest by saying things like "Tell me more, I'm listening." This lets the speaker know that you value their input and encourages them to continue sharing.
Avoid interrupting: Let the speaker finish their thoughts before responding. Interrupting can disrupt the flow of the conversation and make the speaker feel unheard.

Q 2. According to Fisher's model, what are the key points of Reflective Listening?

Reflective listening takes effort and skill to practice effectively.
Our communication skills can sometimes get in the way of reflective listening by misunderstanding or assuming the speaker's needs.
Reflective thinking involves showing genuine interest and respect for the person's inner wisdom.
Breakdowns in communication can happen if the speaker doesn't express themselves clearly, the listener mishears, or there are different interpretations of words.
Reflective listening helps prevent breakdowns and completes the communication loop.
When using reflective listening, the listener's tone goes down at the end of a reflective statement, which encourages clarification and exploration.
Using phrases like "So you feel..." or "It sounds like you..." can be useful during reflective listening.
Reflective listening has three levels: repeating or rephrasing, inferring meaning through paraphrasing, and reflecting the speaker's feelings (the deepest form).
Adapting the level of reflection based on the situation is effective.
Sometimes, exaggerating or toning down reflections can have benefits, such as influencing the person to reconsider or intensifying their feelings.

Q 3. What are the obstacles in your listening process?

Obstacles in listening process:-

Distractions: Things that divert your attention away from the speaker, like noise, electronic devices, or your own thoughts.
Biases and assumptions: Preconceived ideas or beliefs that can influence your ability to listen openly and without judgment.
Emotional interference: Your own emotions or feelings that may interfere with your ability to understand the speaker objectively.
Lack of concentration: Difficulty in staying focused on what the speaker is saying, leading to missing important details.
Language or accent barriers: Challenges in understanding the speaker due to differences in language or pronunciation.
Physical barriers: Obstacles such as distance, noisy environments, or poor audio quality that hinder effective communication.
Time constraints: Limited time available for listening and responding, which can create pressure and make it harder to listen attentively.

Q 4. What can you do to improve your listening?

Here are simpler step/strategy for improve of active listening:

Pay attention: Give your full presence and listen carefully to the speaker, avoiding any distractions.
Show interest: Use your body language, eye contact, and verbal cues to show that you are interested in what the speaker is saying.
Avoid interrupting: Let the speaker finish talking without interrupting or sharing your own thoughts.
Ask questions for clarity: Ask open-ended questions to make sure you understand the speaker's message correctly.
Paraphrase and summarize: Repeat or rephrase what the speaker said in your own words to show that you understand. Summarize the main points to reinforce your understanding.
Be empathetic: Try to understand the speaker's perspective and emotions, showing that you care and validating their feelings.
Manage biases: Be aware of your own biases or assumptions and put them aside to listen objectively and without judgment.
Practice active listening: Engage actively by nodding, smiling, and using verbal cues to show that you are actively listening and understanding.
Avoid distractions: Create a quiet and focused environment for listening by minimizing distractions, like turning off notifications on your devices.
Reflect before responding: Take a moment to gather your thoughts before responding, making sure your response aligns with what the speaker shared.

Q 5. When do you switch to Passive communication style in your day to day life?

Sometimes, when someone asks us about something, like how we look or what we think of their work, we might say positive things even if we don't truly feel that way. We do this to avoid hurting their feelings or causing any discomfort.
In certain situations, we might say we're okay with something even if we're not entirely comfortable. We do this to make the other person feel at ease and not cause any inconvenience or awkwardness.

Q 6. When do you switch into Aggressive communication styles in your day to day life?

If someone invites you to a party where people are doing things you don't like, it's okay to decline and explain that it goes against your values. You can respect yourself and your friend's choices at the same time.
When working on a group project, it's good to confidently share your ideas and suggestions. However, it's also important to listen to others and not take over the conversation or ignore their input.

Q 7. When do you switch into Passive Aggressive (sarcasm/gossiping/taunts/silent treatment and others) communication styles in your day to day life?

My roommate intentionally plays loud music at night even after I politely asked them to be quiet. This noise is bothering me and affecting my sleep.
During a team meeting, there might be someone who makes mean comments and rolls their eyes when others share ideas they don't like. This behavior is disrespectful and can discourage open communication.

Q 8. How can you make your communication assertive?

Here is some steps to make communication assertive:-

Clearly express your thoughts, feelings, and needs without beating around the bush or using ambiguous language.
Use "I" statements: Speak from your perspective using "I" statements to convey your thoughts and feelings, rather than blaming or accusing others. For example, say, "I feel..." or "I think..."
Maintain good eye contact and confident body language: Look the person in the eye and use assertive body language.
Show genuine interest in the other person's perspective by actively listening to what they have to say. Avoid interrupting and try to understand their point of view.
Set boundaries: Clearly communicate your limits and boundaries, expressing what you are comfortable with and what you are not.
Stay calm and composed: Keep your emotions in check and remain calm, even if the conversation becomes challenging or confrontational.
Practice assertive phrases: Use assertive phrases to express yourself effectively, such as "I respectfully disagree," "I need some time to think about it," or "I would appreciate it if you could..."
Practice assertive role-playing: Role-play challenging situations with a trusted friend or mentor to build your confidence and develop assertive communication skills.
Reflect and learn: After assertive communication interactions, reflect on what went well and what could be improved. Continuously learn and refine your assertiveness skills through practice and feedback.

No SQL Database

Ankit Kumar — Sun, 14 May 2023 13:44:03 +0000

NoSQL databases are non-tabular databases and store data differently than relational tables. They provide flexible schemas and scale easily with large amounts of data and high user loads.

Why NoSQL

Flexible data model: NoSQL databases offer a flexible data model for modern applications with complex data requirements.
Scalability: NoSQL databases are designed to scale horizontally. This makes it easier to handle high traffic and large data volumes.
High performance: NoSQL databases are optimized for high-speed reads and writes, making them ideal for applications that require low latency and high throughput.
Availability: NoSQL databases are designed to be highly available, with built-in replication and failover mechanisms that ensure your data is always accessible.
Cost-effective: NoSQL databases are often more cost-effective than traditional relational databases, as they can be run on commodity hardware and require less maintenance.

Types of NoSQL Database

Document-oriented databases: These databases store data in JSON or BSON documents, making them flexible and scalable. Examples include MongoDB and Couchbase.
Key-value databases: These databases store data in key-value pairs, making them highly performant for simple operations like read/write operations. Examples include Redis and Riak.
Column-family stores: These databases store data in columns rather than rows, making them ideal for use cases that require querying large amounts of data. Examples include Apache Cassandra and HBase.
Graph databases: These databases store data in nodes and edges, making them ideal for use cases that require complex relationships and hierarchical data structures. Examples include Neo4j and OrientDB.
Object-oriented databases: These databases store data in objects, making them ideal for use cases that require complex data modeling and object-oriented programming.

How will i investigate using a NoSQL database for improving performance
Define the scope of the investigation: Identify the specific use case for the NoSQL database and determine the data requirements and expected workload.
Research different NoSQL database types: Explore the different types of NoSQL databases, such as document-oriented, key-value, column-family stores, graph databases, and object-oriented databases, to determine which type is best suited for the use case.
Evaluate database options: Once the type of NoSQL database has been determined, evaluate different database options within that type to determine which database best meets the specific requirements of the project.
Perform a proof-of-concept: Before making a final decision, perform a proof-of-concept to test the performance, scalability, and functionality of the chosen NoSQL database in a realistic environment.
Analyze the results: Analyze the results of the proof-of-concept to determine if the NoSQL database meets the performance and scaling requirements of the project.
Consider the impact on the existing infrastructure: Evaluate the impact that adding a NoSQL database will have on the existing infrastructure and determine if any modifications are required.
Evaluate the cost: Determine the cost of implementing and maintaining the NoSQL database over time, including licensing fees, hardware costs, and ongoing maintenance and support.
Make a recommendation: Based on the investigation and analysis, make a recommendation on whether or not to use a NoSQL database and which specific database to use.

References

GeeksforGeeks
MongoDb

SOLID Principle in Python

Ankit Kumar — Sun, 14 May 2023 12:35:14 +0000

The SOLID Principles are five principles of Object-Oriented class design. They are a set of rules for certain design patterns and software architecture in general.

S - Single responsibility principle
O - Open-Closed principle
L - Liskov substitution principle
I - Interface segregation principle
D - Dependency inversion principle

Single responsibility principle

A class should have only one job. If a class has more than one responsibility,
it becomes coupled. A change to one responsibility results to modification of
the other responsibility.

class FileReader:
    def __init__(self, filename):
        self.filename = filename

    def read_file(self):
        with open(self.filename, 'r') as file:
            data = file.read()
        return self.parse_data(data)

    def parse_data(self, data):
        # Parsing logic here
        return parsed_data

Above example, the FileReader class is violating the Single Responsibility Principle because it has two responsibilities: reading data from a file and parsing the data.

To fix this, we can create a separate class for parsing the data:

class FileReader:
    def __init__(self, filename):
        self.filename = filename

    def read_file(self):
        with open(self.filename, 'r') as file:
            data = file.read()
        return data

class DataParser:
    def parse_data(self, data):
        # Parsing logic here
        return parsed_data

Open-Closed principle

Software entities (Classes, modules, functions) should be open for extension, not for modification.

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

    def get_name(self) -> str:
        pass

animals = [
    Animal('lion'),
    Animal('mouse')
]

def animal_sound(animals: list):
    for animal in animals:
        if animal.name == 'lion':
            print('roar')

        elif animal.name == 'mouse':
            print('squeak')

animal_sound(animals)

Above example function animal_sound does not conform to the open-closed principle because it cannot be closed against new kinds of animals. If we add a new animal . We have to modify the animal_sound function.

To fix this we can create a new class for every animal which extend Animal and implement make_sound method.

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

    def get_name(self) -> str:
        pass

    def make_sound(self):
        pass


class Lion(Animal):
    def make_sound(self):
        return 'roar'


class Snake(Animal):
    def make_sound(self):
        return 'hiss'


def animal_sound(animals: list):
    for animal in animals:
        print(animal.make_sound())

animal_sound(animals)

Now, if we add a new animal, animal_sound doesn’t need to change. All we need to do is add the new animal to the animal array.

Liskov substitution principle

The Liskov Substitution Principle is a design principle that states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

def animal_sound(animal):
    return animal.make_sound()

dog = Dog()
cat = Cat()

print(animal_sound(dog)) # Output: "Woof!"
print(animal_sound(cat)) # Output: "Meow!"

Dog or a Cat object to the animal_sound function without affecting the correctness of the program. This is because both Dog and Cat are subtypes of Animal, and they implement the same make_sound method in their own way.

Interface segregation principle

The Interface Segregation Principle (ISP) is a design principle that states that no client should be forced to depend on methods it does not use. In other words, we should break interfaces into smaller, more specific interfaces so that clients only need to implement the methods they actually use.

class IAnimal:
    def eat(self):
        pass

    def sleep(self):
        pass

    def make_sound(self):
        pass

class Dog(IAnimal):
    def eat(self):
        return "Dog is eating."

    def sleep(self):
        return "Dog is sleeping."

    def make_sound(self):
        return "Woof!"

class Cat(IAnimal):
    def eat(self):
        return "Cat is eating."

    def sleep(self):
        return "Cat is sleeping."

    def make_sound(self):
        return "Meow!"

In above example class is forcing its clients to implement all three methods of the Animal class, even if they only need to use one or two methods for training.

To fix this, we can break down the Animal interface into smaller, more specific interfaces:

class IEatable:
    def eat(self):
        pass

class ISleepable:
    def sleep(self):
        pass

class IMakeSoundable:
    def make_sound(self):
        pass

class Dog(IEatable, IMakeSoundable):
    def eat(self):
        return "Dog is eating."

    def make_sound(self):
       return "Woof!"

class Cat(IEatable, ISleepable, IMakeSoundable):
    def eat(self):
        return "Cat is eating."

    def sleep(self):
        return "Cat is sleeping."

    def make_sound(self):
        return "Meow!"

we have broken down the Animal interface into three smaller interfaces - IEatable, ISleepable, and IMakeSoundable. The Dog and Cat classes now implement these smaller interfaces instead of the larger Animal interface.

Dependency inversion principle

The Dependency Inversion Principle (DIP) is a design principle that states that high-level modules should not depend on low-level modules, but both should depend on abstractions. This means that instead of depending on concrete implementations, we should depend on abstract interfaces or classes.

Here's a simple example in Python to illustrate the Dependency Inversion Principle:

class IA:
    def get(self):
        pass

class A(IA):
    def __init__(self):
        self.a=[1,2,3,4]

    def get(self):
        return self.a


class B:
    def __init__(self, obj:IA):
        self.obj=obj

    def get(self):
        print(self.obj.get())

class C(IA):
    def __init__(self):
        self.b=[1,2,3]
    def get(self):
        return self.b

a=A()
c=C()
b1=B(c) # output : [1,2,3]
b2=B(a) # output : [1,2,3,4]
b.get()

we have introduced an abstract interface called ILightSource that defines the turn_on and turn_off methods that the LightSwitch class needs to use. The LightBulb class now implements this interface instead of having its own methods.

References

GeeksforGeeks
freecodecamp

SQL Concepts - Technical Paper

Ankit Kumar — Fri, 12 May 2023 10:31:03 +0000

ACID

ACID stands for Atomicity, Consistency, Isolation, and Durability. These properties are fundamental to ensure that transactions in a database system are reliable and maintain data integrity.

1. Atomicity

Atomicity ensures that a transaction is treated as a single unit of work that either succeeds or fails as a whole.

2. Consistency

Consistency ensures that a transaction must preserve the integrity constraints defined in the database schema.

3. Isolation

Isolation ensures that concurrent transactions do not interfere with each other. Each transaction must execute as if it is the only transaction in the system.

4. Durability

Durability ensures that once a transaction is committed, its effects are permanent and can survive system failures, such as power outages or hardware failures.

CAP Theorem

The CAP theorem states that it is impossible for a distributed system to provide Consistency, Availability, and Partition tolerance simultaneously.

1. Consistency

Consistency requires that all nodes in the distributed system see the same data at the same time. For example, if a user updates a record in one node, all other nodes must see the updated record immediately.

2. Availability

Availability requires that the system responds to every read or write request, even in the presence of node failures or network partitions.

3. Partition

Partition tolerance requires that the system continues to operate even when network partitions occur.

JOINS

Joins in SQL are used to combine data from two or more tables based on a common column or set of columns.

Types of joins:- ### 1.INNER JOIN An INNER JOIN returns only the rows from both tables that have matching values in the join condition.

Syntax:-

SELECT columns FROM table1
INNER  JOIN table2
ON table1.column = table2.column;

2. LEFT JOIN

A LEFT JOIN returns all the rows from the left table and the matching rows from the right table. If there is no matching row in the right table, the result will contain NULL values for the right table columns.

Syntax:-

```
SELECT columns FROM table1
LEFT JOIN table2
ON table1.column = table2.column;
```

3. RIGHT JOIN

A RIGHT JOIN is similar to a LEFT JOIN, but it returns all the rows from the right table and the matching rows from the left table. If there is no matching row in the left table, the result will contain NULL values for the left table columns.

Syntax:-

```
SELECT columns FROM table1
RIGHT JOIN table2
ON table1.column = table2.column;
```

4. OUTER JOIN

An OUTER JOIN returns all the rows from both tables, with NULL values for the columns where there is no match.

Syntax:-

```
SELECT  columns FROM  table1
OUTER  JOIN  table2  ON  table1.columns = table2.columns;
```

Aggregations, Filters in queries

Aggregations and filters are common operations used in SQL queries to summarize and manipulate data.

Some common aggregations:-

sum To calculate total column values.

AVG AVG() function returns the average value of a numeric column.

count COUNT() function returns the number of rows that matches a specified criterion.

MAX MAX() return max value of column.

MIN MIN() returns min value of column

Some filter technique:-
WHERE

The WHERE clause specifies a condition that must be met for each row to be selected in the result set.

You can also use comparison operators such as less than (<) , greater than (>), equal to (=), not equal to (!= or <>) and logical operators such as AND and OR , BETWEEN to create more complex filter conditions. Here's an example:

 SELECT *
FROM sales
WHERE (product = 'product_name' AND price > 100) OR price > 200;

NORMALIZATION

Normalization is the process of organizing data in a database to reduce data redundancy and improve data integrity. In Postgres, normalization is achieved through the use of various normal forms.

First Normal Form (1NF) To achieve 1NF, a table must have a primary key and all columns in the table must contain atomic values (i.e., values that cannot be further decomposed).

CREATE TABLE orders (
  order_id INTEGER PRIMARY KEY,
  customer_name TEXT
);

CREATE TABLE order_items (
  order_id INTEGER REFERENCES orders(order_id),
  item_name TEXT,
  PRIMARY KEY (order_id, item_name)
);

Second Normal Form (2NF) > To achieve 2NF, a table must be in 1NF and all non-key columns must be fully dependent on the primary key. >

        CREATE TABLE sales (
        sale_id INTEGER PRIMARY KEY,
      product_name TEXT REFERENCES 
          products(product_name),
      product_price DECIMAL(10,2)
      );

      CREATE TABLE products (
      product_name TEXT PRIMARY  KEY,
      product_category TEXT
     );

Third Normal Form(3NF) > To achieve 3NF, a table must be in 2NF and all non-key columns must be dependent only on the primary key (not on other non-key columns).

    CREATE TABLE employees (
  employee_id INTEGER PRIMARY KEY,
  employee_name TEXT,
  department_name TEXT REFERENCES departments(department_name)
);

CREATE TABLE departments (
  department_name TEXT PRIMARY KEY,
  manager_name TEXT
);

Boyce CoddNormal Form (BCNF) > The first condition for the table to be in Boyce Codd Normal Form is that the table should be in the third normal form. Secondly, every Right-Hand Side (RHS) attribute of the functional dependencies should depend on the super key of that particular table.

INDEXES

Indexing is used to optimize the performance of a database by minimizing the number of disk accesses required when a query is processed.

Syntax:-

  CREATE  INDEX  _index_name_  
  ON  _table_name_ (_column1_, _column2_, ...);

TRANSACTIONS

A transaction is an action or series of actions. It is performed by a single user to perform operations for accessing the contents of the database.

States of Transactions > A transaction in a database can be in one of the following states.
Active − In this state, the transaction is being executed. This is the initial state of every transaction.
Partially Committed − When a transaction executes its final operation, it is said to be in a partially committed state.
Failed − A transaction is said to be in a failed state if any of the checks made by the database recovery system fails. A failed transaction can no longer proceed further.
Aborted − If any of the checks fails and the transaction has reached a failed state, then the recovery manager rolls back all its write operations on the database to bring the database back to its original state where it was prior to the execution of the transaction. Transactions in this state are called aborted. The database recovery module can select one of the two operations after a transaction aborts −
- Re-start the transaction
- Kill the transaction
Committed − If a transaction executes all its operations successfully, it is said to be committed. All its effects are now permanently established on the database system.

LOCKING MECHANISM

Locking is a fundamental mechanism in database systems that allows
multiple users to access shared resources without interfering with each other.

Types of Locking Mechanism
Shared lock(S) > A shared lock can be imposed by several transactions at the same time over the same page or row and in that way several transactions can share the ability for data reading since the reading process itself will not affect anyhow the actual page or row data. In addition, a shared lock will allow write operations, but no DDL changes will be allowed.
Exclusive lock > The exclusive lock will be imposed by the transaction when it wants to modify the page or row data, which is in the case of DML statements DELETE, INSERT and UPDATE. An exclusive lock can be imposed to a page or row only if there is no other shared or exclusive lock imposed already on the target.
Update lock > An update lock is acquired when a transaction intends to modify a resource and wants to prevent other transactions from acquiring an exclusive lock on the same resource.

DATABASE ISOLATION LEVELS

Database isolation levels are a key feature of database management systems that allow multiple transactions to access the same data concurrently while maintaining data consistency and integrity.

Different database isolation levels
Read Uncommitted Isolation Level >The read uncommitted isolation level allows a transaction to read uncommitted changes made by other transactions,
Read Committed Isolation Level > The read committed isolation level allows a transaction to read only committed changes made by other transactions, which eliminates dirty reads but can result in non-repeatable reads.
Repeatable Read Isolation Level > The repeatable read isolation level guarantees that a transaction can read the same data multiple times without interference from other transactions, which eliminates non-repeatable reads but can result in phantom reads.
Serializable Isolation Level > The serializable isolation level provides the highest level of consistency by ensuring that concurrent transactions appear to execute serially, which eliminates all types of concurrency anomalies but reduces concurrency to the lowest level.

TRIGGERS

A trigger is a set of actions that are run automatically when a specified change operation (SQL INSERT, UPDATE, DELETE or TRUNCATE statement) is performed on a specified table.

Create trigger: In PostgreSQL, the CREATE TRIGGER command generates our first trigger step by step.
Alter trigger: The ALTER TRIGGER command is used to rename a trigger.
Drop trigger: The DROP TRIGGER command is used to define the steps to remove a trigger from a table
Enable triggers: In the PostgreSQL trigger, the ENABLE TRIGGER statement allows a trigger or all triggers related to a table.
Disable trigger: The DISABLE TRIGGER is used to display how we can disable a trigger or all triggers linked with a table.

Object Oriented Programming in Python

Ankit Kumar — Thu, 11 May 2023 05:42:53 +0000

Introduction of OOPs in Python

Python supports object-oriented programming through the use of classes, objects, attributes, and methods. These concepts allow you to create modular and reusable code that is easier to understand and maintain.

Everything in Python is an object. Using Pythom we can create classes and objects.

Classes

Class is like a blueprint of an real object. Classes defines object features and attributes which help to create objects.
Class comprises of properties and behaviour.

For eg:- Consider a class Person, it might have properties or behaviour of person. Those properties might be name, age, etc.
How to make a Class in Python. We use Class keyword.

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

    def say_hello(self):
            print(f"Hello, my name is {self.name} and I am {self.age} years old.")
person = Person("John", 30)

Objects

Objects is real world entity which contains all features defines in class. It is instance of their class.

This may be any real-world object.
For eg:- In case of a class Person, we can have real world objects john, ankit etc.

john = Person("John", 30)
ankit = Person("ankit", 25)

Objects consists of attributes/properties .
It consists of behaviour represented by the methods of an object.
Identity gives a unique name to an object.

Inheritance

Inheritance is one of the key features of object-oriented programming, and Python supports it as well. Inheritance allows you to create a new class that is a modified version of an existing class, inheriting all the attributes and methods of the parent class.
For eg:- In this example, we define a new class called Student that inherits from the Person class

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

    def say_hello(self):
        super().say_hello()
        print(f"I am a student in grade {self.grade}.")

Types of Inheritance:-

1. Single level Inheritance:

Single-level inheritance enables a derived class to inherit characteristics from a single-parent class.
example :-

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

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

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade
my_student = Student("John", 18, "12th")
my_student.say_hello()
#output: Hello, my name is John and I am 18 years old.

2. Multilevel Inheritance :
Multi-level inheritance enables a derived class to inherit properties from an immediate parent class which in turn inherits properties from his parent class.
example :-

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

    def eat(self):
        print(f"{self.name} is eating.")

class Mammal(Animal):
    def walk(self):
        print(f"{self.name} is walking.")

class Dog(Mammal):
    def bark(self):
        print(f"{self.name} is barking.")

class LabradorRetriever(Dog):
    def fetch(self):
        print(f"{self.name} is fetching.")

my_dog = LabradorRetriever("Buddy")
# output
my_dog.eat()    # Buddy is eating.
my_dog.walk()   # Buddy is walking.
my_dog.bark()   # Buddy is barking.
my_dog.fetch()  # Buddy is fetching.

3. Hierarchical Inheritance:

Hierarchical inheritance in Python involves creating a class hierarchy where multiple subclasses inherit from the same parent class. In other words, it's a structure where one parent class has multiple child classes.
example :-

 # Base class
 class  Animal: 
 def  __init__(self, name):
      self.name = name 
 def  speak(self):
      pass
 # Subclass 1
 class  Dog(Animal):
      def  speak(self):
           print(f"{self.name} says woof.")
 #Subclass 2
 class  Cow(Animal):
     def  speak(self):
         print(f"{self.name} says moo.")
my_dog = Dog("Buddy")
my_cow = Cow("MooMoo")
 # output
my_dog.speak()  # Buddy says woof.
my_cow.speak()  # MooMoo says moo.

4.Multiple Inheritance:
Multiple level inheritance enables one derived class to inherit properties from more than one base class.
example :-

class  Animal: 
    def  __init__(self, name, species): 
        self.name = name 
        self.species = species 
class  Carnivore: 
    def  __init__(self): 
        self.is_carnivore = True  
    def  eat(self): 
        print("I eat meat.")

class  Cat(Animal, Carnivore): 
    def  __init__(self, name): 
        Animal.__init__(self, name, species="Cat") 
        Carnivore.__init__(self)  
        self.sound = "Meow"

cat1 = Cat("Luna")
print(cat1.name, cat1.species, cat1.sound, cat1.is_carnivore)
 #output: Luna Cat Meow True

Polymorphism

polymorphism in Python allows you to write code that works with objects of different classes through a shared interface. This can make your code more flexible and reusable, and allow you to take advantage of inheritance and other OOP features.
example :-

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

    def make_sound(self):
        pass

class Dog(Animal):
    # override methods
    def make_sound(self):
        print(f"{self.name} says woof.")

class Cat(Animal):
    # override methods
    def make_sound(self):
        print(f"{self.name} says meow.")

my_dog = Dog("Buddy")
my_cat = Cat("Kitty")
 #output
 my_dog.make_sound()  # Buddy says woof.
my_cat.make_sound()  # Kitty says meow.

Encapsulation

Encapsulation in Python allows you to hide the implementation details of an object from the outside world, and expose only the necessary information through a well-defined interface. This can help to achieve data security, modularity, and maintainability of code.
example :-

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

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age < 0:
            raise ValueError("Age cannot be negative.")
        self.__age = age

person = Person("Alice", 30)
print(person.get_name())  # Alice
person.set_age(35)
print(person.get_age())  # 35

Abstraction

Abstraction is a concept in object-oriented programming that refers to the ability to focus on the essential features of an object or system, while ignoring its less important or irrelevant details. In other words, it allows us to represent complex real-world entities in a simplified and manageable way.
For example :- We define a concrete class ConcreteClass that subclasses AbstractClass and provides implementations of its abstract methods method1 and method2. These implementations provide concrete functionality for the abstract methods, and allow us to use the ConcreteClass as a fully functional class.

 # abstractclass
 import abc
class AbstractClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def method1(self):
        pass
    @abc.abstractmethod
    def method2(self):
        pass
  # Inherit abstract class
class ConcreteClass(AbstractClass):
    def method1(self):
        print("Implementation of method1")
    def method2(self):
        print("Implementation of method2")
 # creating object
obj = ConcreteClass()
obj.method1()
obj.method2()
 # output
 Implementation of method1
Implementation of method2

References

GeeksforGeeks
W3Schools
freecodecamp

Dictionary in Python

Ankit Kumar — Wed, 10 May 2023 18:36:52 +0000

Dictionary is a data structure in python which store as a key:value pair.
Dictionaries do not allow duplicate keys, since it uses hashing concep store keys.

Overview of most used Dictionary Methods

1. declaring a dictionary

dictionary = {}

2. Inserting Key:Value pairs

we have a specific syntax to do it, as shown below.
example:-

 dictionary['name'] = 'ankit'
 print(dictionary) 
 # output  :  { 'name' : 'ankit' }

3. Accessing a Value using Key

There are two ways you can access a value using key
In python, there is a method .get() which takes a key as a argument, used to get a value as shown
.get() will return None , if key is not found in a dictionary
The other way to access a value is using square brackets,

        value = dictionary.get('name')
        print(value)
        #output: 'milk'
        value = dictionary.get('unknown_key')
        print(value)
        #output : None
        # other way
        name = dictionary['name']
        print(name)
        #output: 'milk'

4. Methods used while looping a Dictionary

items() :

The items() method in Python dictionaries returns a view object that contains the key-value pairs of the dictionary as tuples.
example:-

my_dict = {'apple': 2, 'banana': 3, 'cherry': 5}
for key, value in my_dict.items():
    print(key, value)
#output apple 2
        banana 3
        cherry 5

5 .keys():

This method will return dict_keys which are list of keys in a dictionary. we can use loops to access all the keys. example:-

        keys = my_dict.keys()
        for key in keys:
            print(key)
        #output: apple
                 banana
                 cherry

6 .values():

This method will return dict_values which are list of values in a dictionary. we can use loops to access all the values.
example:-
```
    values = my_dict.values()
    for value in values:
        print(value)
    #output: 2 3 5
    ```
```

7. in:

It is a keyword which can be used to find weather the key is present or not it will return a boolean value as shown example:-

        boolean = 'banana' in my_dict
        print(boolean)
        #output: True
        boolean = 'unknown_key' in my_dict
        print(boolean)
        #output: False

8. update():

This will take another dictionary as argument and addes it to the old one
example:-

    new_dict = { 'Lemon' : 10 }
    my_dict.update(new_dict)
    print(my_dict)
    #output: {'apple': 2, 'banana': 4, 'cherry': 5, 'Lemon':10}

9 .copy():

This method copies the entire dictionary to the new one example:-

         new_dict = my_dict.copy()
         print(new_dict)
        #output: {'apple': 2, 'banana': 4, 'cherry': 5,   'Lemon':10}

10. Update existing key using Square Brackets

We can append a key value pair in to a dictionary or we can update a value using the key as shown. example:-

     my_dict = {'apple': 2, 'banana': 3, 'cherry': 5}
my_dict['banana'] = 4
print(my_dict)
#output : {'apple': 2, 'banana': 4, 'cherry': 5}

11 .pop('key'):

This method will take key as a argument and will remove the key value pair from dictionary as shown
It will return a value of the key that was poped
This will through KeyError if key is not found example:-

my_dict = {'apple': 2, 'banana': 3, 'cherry': 5}
my_dict.pop('banana')
print(my_dict)
#output {'apple': 2, 'cherry': 5}

12. popitem():

This method will pop the last item that was inserted and will return a tuple of key and value
This will return KeyError if dictionary is empty example:-

my_dict = {'apple': 2, 'banana': 3, 'cherry': 5}
item = my_dict.popitem()
print(item)
print(my_dict)
#output ('cherry', 5)
      {'apple': 2, 'banana': 3}

13 .clear():

This method will clear the dictionary and returns None example:-

        my_dict.clear() 
        print(my_dict)
        #output: {}

14 .setdefault()

Returns the value of a key if the key is in the dictionary else inserts the key with a value to the dictionary example:-

my_dict = {'apple': 2, 'banana': 3, 'cherry': 5}
value = my_dict.setdefault('banana', 10)
print(value)
print(my_dict)

value = my_dict.setdefault('orange', 7)
print(value)
print(my_dict)
#0utput 3
             {'apple': 2, 'banana': 3, 'cherry': 5}
            7
           {'apple': 2, 'banana': 3, 'cherry': 5, 'orange': 7}

References:

List methods in Python

Ankit Kumar — Wed, 10 May 2023 17:30:57 +0000

An overview of string methods in Python

In this article, I will provide an overview of the most commonly used string methods in Python.

1. append()

Used for appending and adding elements to the end of the List.
example:-

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # Output: [1, 2, 3, 4]

2. copy()

It returns a shallow copy of a list
example:-

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # Output: [1, 2, 3]

3. clear()

This method is used for removing all items from the list.
example:-

my_list = [1, 2, 3] 
my_list.clear() print(my_list) # Output: []

4. count()

These methods count the elements
example:-

my_list = [1, 2, 3, 2, 4, 2]
count = my_list.count(2)
print(count)  # Output: 3

5. extend()

Adds each element of the iterable to the end of the List
example:-

my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # Output: [1, 2, 3, 4, 5, 6]

6. index()

Returns the lowest index where the element appears.
example:-

my_list = [1, 2, 3, 2, 4, 2]
index = my_list.index(2)
print(index)  # Output: 1

7. insert()

Inserts a given element at a given index in a list.
example:-

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 'hello')
print(my_list)  # Output: [1, 2, 'hello', 3, 4, 5]

print("My name is {}, and I'm {} years old.".format(name, age))
 Output: "My name is Ankit, and I'm 25 years old."

8. pop()

Removes and returns the last value from the List or the given index value.
example:-

my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop(2)
print(removed_element)  # Output: 3
print(my_list)  # Output: [1, 2, 4, 5]

9. remove()

Removes a given object from the List.
example:-

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)  # Output: [1, 2, 4, 5]

10. sort()

Sort a List in ascending, descending, or user-defined order
default is ascending and for reverse write 'reverse=True.
example :-

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

11. List as Stack

Stack is data structure which works on last in first out principle.
List can be used as a stack by using the append() method to add elements to the top of the stack and the pop()
example:-

stack = []
stack.append('A')
stack.append('B')
stack.append('C')
print(stack)  # Output: ['A', 'B', 'C']
top = stack.pop()
print(top)  # Output: 'C'
print(stack)  # Output: ['A', 'B']

12. List as Queue

Queue is data structure which work on last in last out principal.
A list can be used as a queue by using the append() method to add elements to the end of the queue and the pop(0)
example:-

queue = []
queue.append('A')
queue.append('B')
queue.append('C')
print(queue)  # Output: ['A', 'B', 'C']
front = queue.pop(0)
print(front)  # Output: 'A'
print(queue)  # Output: ['B', 'C']

Using the pop(0) method to remove elements from the beginning of a list can be inefficient for large lists, as it requires shifting all the remaining elements one position to the left. If you need to implement a more efficient queue, it's recommended to use the deque class from the collections module
example:-

from collections import deque

queue = deque()
queue.append('A')
queue.append('B')
queue.append('C')
print(queue)  # Output: deque(['A', 'B', 'C'])
front = queue.popleft()
print(front)  # Output: 'A'
print(queue)  # Output: deque(['B', 'C'])

Referances

python docs
geeksForGeeks

List Methods in Python

Ankit Kumar — Wed, 10 May 2023 17:26:08 +0000

An overview of string methods in Python

In this article, I will provide an overview of the most commonly used string methods in Python.

1. append()

Used for appending and adding elements to the end of the List.
example:-

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # Output: [1, 2, 3, 4]

2. copy()

It returns a shallow copy of a list
example:-

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # Output: [1, 2, 3]

3. clear()

This method is used for removing all items from the list.
example:-

my_list = [1, 2, 3] 
my_list.clear() print(my_list) # Output: []

4. count()

These methods count the elements
example:-

my_list = [1, 2, 3, 2, 4, 2]
count = my_list.count(2)
print(count)  # Output: 3

5. extend()

Adds each element of the iterable to the end of the List
example:-

my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # Output: [1, 2, 3, 4, 5, 6]

6. index()

Returns the lowest index where the element appears.
example:-

my_list = [1, 2, 3, 2, 4, 2]
index = my_list.index(2)
print(index)  # Output: 1

7. insert()

Inserts a given element at a given index in a list.
example:-

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 'hello')
print(my_list)  # Output: [1, 2, 'hello', 3, 4, 5]

print("My name is {}, and I'm {} years old.".format(name, age))
 Output: "My name is Ankit, and I'm 25 years old."

8. pop()

Removes and returns the last value from the List or the given index value.
example:-

my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop(2)
print(removed_element)  # Output: 3
print(my_list)  # Output: [1, 2, 4, 5]

9. remove()

Removes a given object from the List.
example:-

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)  # Output: [1, 2, 4, 5]

10. sort()

Sort a List in ascending, descending, or user-defined order
default is ascending and for reverse write 'reverse=True.
example :-

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

11. List as Stack

Stack is data structure which works on last in first out principle.
List can be used as a stack by using the append() method to add elements to the top of the stack and the pop()
example:-

stack = []
stack.append('A')
stack.append('B')
stack.append('C')
print(stack)  # Output: ['A', 'B', 'C']
top = stack.pop()
print(top)  # Output: 'C'
print(stack)  # Output: ['A', 'B']

12. List as Queue

Queue is data structure which work on last in last out principal.
A list can be used as a queue by using the append() method to add elements to the end of the queue and the pop(0)
example:-

queue = []
queue.append('A')
queue.append('B')
queue.append('C')
print(queue)  # Output: ['A', 'B', 'C']
front = queue.pop(0)
print(front)  # Output: 'A'
print(queue)  # Output: ['B', 'C']

from collections import deque

queue = deque()
queue.append('A')
queue.append('B')
queue.append('C')
print(queue)  # Output: deque(['A', 'B', 'C'])
front = queue.popleft()
print(front)  # Output: 'A'
print(queue)  # Output: deque(['B', 'C'])

DEV Community: Ankit Kumar

Django Framework

What is secret key?

MVT Architecture

Setting File

Application File

Project Files

CSRF

ORM

References

JS Asynchronous-Technical Paper

Callbacks

Promises

Code Control

References

JAVASCRIPT Technical Paper

Loop

Mutable and Immutable Methods (in strings and arrays)

Pass by Reference and Pass by Value

Array Methods:

String Methods

Object Methods and Opertions

Hoisting

Scopes

Closures

Higher Order Functions

References

HTML - CSS Technical Paper

Box Model

Inline vs Block elements

Common CSS structural classes

Common CSS syling classes

CSS Specificity

CSS Responsive Queries

Flexbox

Grid

Common header meta tags

Css Selectors

References

Listening and Active Communication

Q 1. What are the steps/strategies to do Active Listening?

Q 2. According to Fisher's model, what are the key points of Reflective Listening?

Q 3. What are the obstacles in your listening process?

Q 4. What can you do to improve your listening?

Q 5. When do you switch to Passive communication style in your day to day life?

Q 6. When do you switch into Aggressive communication styles in your day to day life?

Q 7. When do you switch into Passive Aggressive (sarcasm/gossiping/taunts/silent treatment and others) communication styles in your day to day life?

Q 8. How can you make your communication assertive?

No SQL Database

Why NoSQL

Types of NoSQL Database

How will i investigate using a NoSQL database for improving performance

References

SOLID Principle in Python

Single responsibility principle

Open-Closed principle

Liskov substitution principle

Interface segregation principle

Dependency inversion principle

References

SQL Concepts - Technical Paper

ACID

1. Atomicity

2. Consistency

3. Isolation

4. Durability

CAP Theorem

1. Consistency

2. Availability

3. Partition

JOINS

2. LEFT JOIN

3. RIGHT JOIN

4. OUTER JOIN

Aggregations, Filters in queries

NORMALIZATION

INDEXES

TRANSACTIONS

LOCKING MECHANISM

DATABASE ISOLATION LEVELS