DEV Community: Utsav

Django Basics

Utsav — Fri, 16 Jun 2023 12:29:02 +0000

Django

Introduction

A brief technical paper describing the workings of The Django framework.

Pre-requisites: Strong understanding of python.

The Settings File

What is secret key?

A secret key is an important security setting used for cryptographic signing and hashing. It helps protect sensitive information, such as user passwords and session data. The secret key should be kept confidential and should not be shared publicly.
What are the default Django apps inside it? Are there more?

You can find them listed in the INSTALLED_APPS setting in the project's settings module.

django.contrib.admin: provides the Django administration interface, which allows you to manage your project's data through a web-based interface.

django.contrib.auth: handles user authentication and provides the necessary models, views, and forms for managing user accounts, passwords, and permissions.

django.contrib.contenttypes: provides a framework for creating, retrieving, and managing content types. It's used by other apps to associate models with permissions and generic relations.

django.contrib.sessions: enables session management and allows you to store and retrieve session data for visitors.

django.contrib.messages: provides a messaging framework that allows you to store messages for users and display them in a user-friendly way.

django.contrib.staticfiles: handles static files (e.g., CSS, JavaScript, images) and collects them in a single location for deployment.

In addition to these default apps, Django also includes other optional apps that you can choose to include based on your project's requirements. Some of these optional apps include:

`django.contrib.gis`: This app adds geographic information system (GIS) support to Django, allowing you to work with spatial data.

`django.contrib.postgres`: This app includes various features for working with PostgreSQL databases, such as advanced querying capabilities and specific model fields.

What is middleware? What are different kinds of middleware? Read up a little on each security issue.

Middleware in Django is a component that sits between the web server and the view function, allowing you to process requests and responses globally. It provides a way to modify or analyze HTTP requests and responses before they reach the view and after they leave the view, respectively

Django provides several built-in middleware classes, and you can also create your own custom middleware. Here are some of the common types of middleware in Django:
- Authentication Middleware: responsible for associating the user with the request by authenticating the user based on the provided credentials. It sets the request.user attribute, allowing you to identify the user making the request.
- Session Middleware: manages the session data for each visitor and provides the ability to store and retrieve session variables. It enables you to maintain state across multiple requests.
- CSRF Middleware: Cross Site Request Forgery middleware adds protection against CSRF attacks. It validates that the requests made to your site originate from your forms and protects against unauthorized form submissions.
- Security Middleware: Django provides security middleware classes to enforce various security measures. Some of these classes include XFrameOptionsMiddleware (sets the X-Frame-Options header to prevent clickjacking attacks), ContentSecurityPolicyMiddleware (configures Content Security Policy headers), and SecureReferrerPolicyMiddleware (sets the Referrer-Policy header to control referrer information).

Django Security

This is a set of measures implemented in Django, to protect web applications from various security threats and vulnerabilities. Here are some key aspects of Django security:

CSRF protection

Django provides built-in protection against CSRF attacks. CSRF attacks occur when an attacker tricks a user's browser into making unintended requests on a targeted website. Django includes a CSRF token mechanism that validates requests, ensuring they come from trusted sources.
Cross Site scripting protection

Django provides built-in protection against CSRF attacks. CSRF attacks occur when an attacker tricks a user's browser into making unintended requests on a targeted website. Django includes a CSRF token mechanism that validates requests, ensuring they come from trusted sources.
Clickjacking protection

Django includes measures to prevent clickjacking, where an attacker tricks a user into clicking on something malicious without their knowledge. Django supports setting X-Frame-Options headers to control framing of web pages, mitigating clickjacking risks.

WSGI

The Web Server Gateway Interface is a simple calling convention for web servers to forward requests to web applications.

Models

ON DELETE CASCADE

Cascade is used to define the behavior of related records when the referenced record in a parent table is deleted.

OnDelete is one of the options available which specifies that if the parent element of the foreign key is deleted, all the related data should be deleted as well, this is done to maintain referential integrity.
Fileds and Validators

Fields and validators are integral parts of building and managing the database schema and data validation for web applications.

Fields:

Fields in Django represent the columns or attributes of database tables. They define the type of data that can be stored in a particular column and provide additional metadata about the data. Django offers a wide range of field types, including:

CharField: Used for storing strings of a specific length.

IntegerField: Stores integer values.

TextField: Suitable for storing larger amounts of text.

BooleanField: Represents boolean values (True/False).

DateTimeField: Stores date and time information.

ForeignKey: Establishes a relationship between tables, representing a one-to-many relationship.

Validators:

Validators in Django are functions or classes used to validate user input or data before it is stored in the database. They enforce specific constraints or rules on the data, ensuring its integrity and consistency. Django provides several built-in validators, example:

RequiredValidator: Ensures that a field is not empty or null.

MaxValueValidator/MinValueValidator: Validates that a numeric value is within specified maximum or minimum limits.

RegexValidator: Validates that a field matches a specified regular expression pattern.

EmailValidator: Verifies that an input string is a valid email address.

URLValidator: Checks that a given string is a valid URL.
Modules vs Classes

A module in Python is a file that contains Python code, typically with a .py extension. It serves as a container for related functions, classes, and variables that can be reused in different parts of a program.

A class in Python is a blueprint for creating objects. It is a code template that defines the attributes (data) and methods (functions) that an object of that class can have.

Django ORM

Using ORM queries in Django Shell

You can use ORM queries within the django shell to experiment with data.
- Activate the Django shell:
```
python manage.py shell
```
- Import necessary models:
```
from utsav.models import Whatever
```
- Perform queries:
```
all_products = Product.objects.all()
```

Turning ORM to SQL in Django Shell

You can perform the ORM queries and convert them to SQL using the query method. Example:

    query = Product.objects.filter(price__gte=10).query

    sql=query.get_compiler(using=Product.objects.db).as_sql()

    print(sql)

Aggregation

Aggregation queries are equivalent to aggregate functions in SQL, they simply perform aggregation on all the records and return a singular value.
Annotate

Annotations are equivalent to group by statements in SQL, it is used to perform aggregations on fields based on the same or other fields, For example: Getting the sum of total revenue generated by each employee, where we have a table consisting of each sale by employee.
What is a migration file? Why is it needed?

Migration file in Django is an autogenerated Python script that defines the changes to be made to the database schema

Migrations enable version control of your database schema changes. Each migration file represents a specific set of changes to the schema, allowing you to track and revert changes if needed.
What are SQL transactions?

SQL transactions are units of work performed within a relational database management system. A transaction is a sequence of one or more SQL statements that are executed as a single logical unit. These statements can include queries, updates, inserts, and deletes.
What are atomic transactions?

If an error occurs during any step of the transaction, the changes made in the previous steps may or may not be rolled back, leaving the database in an inconsistent state.

Atomic transactions ensure that all operations within a transaction are treated as a single unit, and they are either all successfully applied or none of them are. If any operation within the transaction fails, the changes made in all previous steps are automatically rolled back, maintaining data integrity and consistency.

References

Geeks for Geeks

Django Documentation

JavaScript

Utsav — Mon, 29 May 2023 07:22:44 +0000

The aim of this paper is to help the reader understand basic JavaScript concepts.

Loops

for: A simple for loop that iterates through elements based on index.
```
for(int i=0;i<size;i++){
    //do something here
}
```
forEach: This is a "Higher order function" in JavaScript, does not return anything, makes changes within the array.
```
numbers.forEach(function(number) {
console.log(number);
});
```

for .. in and for .. of: Both of these loop iterate over things in different ways, for .. in iterates over the enumerable properties of an object, while for .. of iterates over the values that the object defines to be iterated over.

//print key/value pairs of an object.

for(let property in object){
    console.log(property,object[property]);
}
//you won't be able to use "for .. of" loop for a single object
//iterating over an array of objects

for(let value of array){
    console.log(value);
}

while: the while loop is an alternative to standard for loops, both can be used interchangeably.
```
let i=0;
while(i<10){
    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 the result.
- 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,]

```

Searching Functions:
- 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"]

Advanced

Array methods chaining

You can chain up methods instead of calling them separately.

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.

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.

Getting All Keys:

Object.keys(object): Returns an array containing all the keys of the object.

Getting All Values:

Object.values(object): Returns an array containing all the values of the object.

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:

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

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.

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

JavaScript(GeeksForGeeks)

JavaScript Objects(W3 Schools)

Mozilla Documentation

HTML and CSS

Utsav — Thu, 18 May 2023 09:05:52 +0000

This paper on HTML and CSS aims to help the reader understand various concepts required for effective and efficient use of css

Basic concepts in HTML

Let's go through all the major tags in HTML:

<html>: Defines the root of an HTML document.
<title>: Used to define the title of the HTML document, it is displayed on the title bar of the page.
<h1> to <h6>: Define headings for the webpage, <h1> is the largest of them, <h6> is the smallest.
<br>: Defines a line break in the webpage.
<p>: Defines paragraphs in the webpage.
<link>: Defines the relationship between a document and an external file (most used to link to style sheets).
<style>: Defines CSS within the HTML file.
<script>: Defines JavaScript code within the HTML file.
<a>: The Anchor tag is used to define hyperlinks, linking one page to another. It has several attributes:
- download: Specifies that the provided target will be downloaded upon being clicked.
- href: Clicking will redirect you to the specified webpage.
- target: Specifies where to open the link (target="__blank" will open the link in a new tab).
<ul>, <ol> and <li>: These tags are used to define lists, <ol> is for ordered lists while <ul> defines unordered lists, <li> are individual elements in the the defined list.
<div>: Defines a division or section in an HTML document. It is a versatile tag used to group and style other elements together. The user can give it properties via classes or ids.
<img>: Used to define images in HTML webpage, The src attribute is used to link the image.
<label>: Used to define name/label for input elements.
<span>: defines a span of text within a document. It is typically used to apply styles or target specific sections of content for scripting purposes.

The HTML document describes the skeleton of our webpage, the design responsibility lies with CSS.

The Box Model

Every element on a page is a rectangle

The image above is a representation of the box model, as you can see, the total size of the box is much more than what you'd expect.

Formula for total width of the box:-

padding= (padding-left+padding-right)
border= (border-left+border-right)
margin=(margin-left+margin-right)

total width=width+padding+border+margin

You can further intuit what the the formula for height would be.

Padding: is to adjust the contents within a container.
Margin is used to adjust the container with respect to its sibling elements.

Inline vs Block Elements

Block Elements:

A block-level element always starts on a new line, and the browsers automatically add some margin before and after the element.
Block elements always occupy the maximum available width by default.

Inline Elements:

Inline elements don't start in a newline.
These elements only take up the necessary amount of width.

Positioning: Relative/Absolute

The position attribute has a lot of possible values, we'll just be talking about relative and absolute.

relative: positioned elements allow us to use left,top,right and bottom attributes, these attributes adjust the position of the element relative to it's normal position.

absolute: same as relative, but this time the object is positioned relative to its nearest relative or absolute ancestor.

In the flow / Out of flow.

It is important to understand the flow of elements within a container when you're adjusting them.
Elements that are in the flow change their surrounds(sibling elements) when they are adjusted in position, and they're also affected when their surroundings change.
Out of flow elements are unaffected by their surroundings as they are positioned relatively to their ancestor, they overlap other elements and can be individually placed anywhere.
Fixed and absolute positions take an element out of flow.
absolute is very useful when you're dealing with overlapping elements.

Common CSS pseudo classes

In this section we'll be dealing with pseudo selectors
Pseudo selectors are used to select child elements based on a pattern.
:first-child selects the first child within an element.
:nth-child[n]: used to select a sequence of child elements based on a pattern. for example:
```
.class:nth-child[2n+1]
```
The code above will select 3^rd,5^th,7^th....(2n+1)^th child elements from a class/element.
:last-child selects the last child.
:nth-last-child[n]: same as nth-child but selects the elements in reverse order.
:nth-of-type[n] selects elements of the same type based on a given expression.

Common CSS structures

CSS classes can be added to any element in an html, let's explore some common usages:

<p>, <div>, <body>, <span>, <a> etc.

You can select structres from specific classes:

    class-1 p{
        text-align:center;
    }

The code above only applies to all the <p> elements within class-1.

CSS Specificity

If we have two or more rules that we're applying to the same element, then the webpage will use the specifity value of a rule to decide which one will be applied to the element.

Priority 1: Inline styles, the rules declared inline will override all the previous styles that would've been applied using classes or ids.
```
<h1 style="color:pink;"> Hi</h1>
```
Priority 2: IDs, IDs are like classes but they're unique for every element whereas one class can be applied to several elements.
```
#example-id{
    color:pink;
}
```

Priority 3: Classes, pseudo-classes and attribute selectors:

.class-1{
    color:pink;
}
.class-1:hover{
    color:blue;
}
[target]{}

Priority 4: Elements and pseudo elements:
```
h1{
    color:grey;
}
```

CSS responsive queries

Responsive queries are used to adjust the design of a website according to a certain property (usually width and orientation).
We use the @media rule to manage these queries. Example:

     @media only screen and (max-width: 600px) {
    body {
        background-color: lightblue;
        }
    }

The code above changes the the background color if the width dips below 601px.

Flexbox

Flexbox is a useful way to structure your HTML code, It has useful attributes that allow you to place elements within the container with a lot of freedom.

Some commonly used flex-box properties:

flex-direction: specifies the direction of the flow of elements, row displays elements row-wise, column; column-wise. The value of this attribute is row by default.
justify-content: used to position elements horizontally(vertically is the flex-direction is column), center brings everything to center.space-around,space-between and space-evenly spread out the data with varying spaces between them.
align-items: used to align the items within a container vertically(horizontally if the flex-direction is column).flex-start and end bring the elements to opposite sides of the container, while center brings everything to center.
flex-wrap: wraps the container so elements are not stuck in a single line, instead they're spread out throughout the container.
order: can change the order in which elements appear in the container, this property is 0 by default.
grow and shrink increases or decreases the size of the flex-item based on the size of the flex-container.

Grids

Grids have a lot of similar properties as flex, we'll just be talking about what sets grid apart.

Defining a container as a grid of multiple boxes:

    .class-1{
        display:grid;
        grid-template-rows: 1fr 1fr 1fr;
        grid-template-columns:1fr 1fr;
    }

The code above splits container into three rows and two columns. we can use the repeat function to automate the process.
```
.class-1{
    display:grid;
    grid-template-rows: repeat(100,1fr);
    grid-template-rows: repeat(100,1fr);
}
```
The code above splits it into 100 rows and columns.

Precisely placing grid items withing a grid container:

    grid-item-1{
        grid-column: 1/10;
        grid-row:1/5;
    }

The item above will cover the first 10 column items and first 5 row items.

row-gap and column-gap: used to define a gap between grid items.

    .class-1{
        display:grid;
        grid-template-rows: 1fr 1fr 1fr;
        grid-template-columns:1fr 1fr;
        row-gap:20px;
    }

Places a gap of 20px between all containers.

Common meta header tags

Metadata is used by browsers (how to display content or reload page), search engines (keywords), and other web services.

    <head>
    <meta charset="UTF-8">
    <meta name="description" content="Free Web tutorials">
    <meta name="keywords" content="HTML, CSS, JavaScript">
    <meta name="author" content="John Doe">
    <meta name="viewport" 
    content="width=device-width, initial-scale=1.0">
    </head>

charset defines the character encoding of the document.

Keywords is used by search engines to display your webpages in results.

viewport is used to define the scale of the viewport width and height for the website.

References:

SOLID Principles

Utsav — Mon, 15 May 2023 08:48:20 +0000

The aim of this paper is to make the readers familiar with the concepts of SOLID principles. They are essentially a set of practices that leads to well designed software (Readable,Modular,Scalable)

Single Responsibility Principle

Basic gist :

Every class must have a single responsibility to fulfill
If a class is performing too many tasks, especially if the tasks are logically unrelated, then you would be better off writing another class.

How it plays out :

A bad example :

    #Class below is reponsilble for user properties and user database management
    class  User:
        def __init__(self, name: str):
            self.name = name

        def get_name(self) -> str:
            pass

        def save(self, user: User):
            pass

If some changes are passed to the database management system, all the classes working with user properties will have to be recompiled to compensate for new changes.

The correct way :

    #Simply split the classes.
    class User:
        def __init__(self, name: str):
                self.name = name

        def get_name(self):
            pass


    class UserDB:
        def get_user(self, id) -> User:
            pass

        def save(self, user: User):
            pass

Open/Closed principle

This principle states that classes should be open to extension, not to modification. If you want to add some functionality to a class, you are better off extending it, avoiding violating the Single responsibility principle.

A bad example:

    class Discount:
        def __init__(self, customer, price):
            self.customer = customer
            self.price = price

        def give_discount(self):
            if self.customer == 'fav':
                return self.price * 0.2

            if self.customer == 'vip':
                return self.price * 0.4

The above class is responsible for giving out discounts, however modifying the class to add the vip discount condition violates the open/closed principle, instead do this:

The correct way:

    class Discount:
        def __init__(self, customer, price):
            self.customer = customer
            self.price = price

        def get_discount(self):
            return self.price * 0.2

    class VIPDiscount(Discount):
        def get_discount(self):
            return super().get_discount() * 2

Here, we create a new class that handles the vip discount method.

Liskov Substitution principle

The objects of a sub class should be able to replace the objects of its parent class without any changes in behavior.

    class Bird():
        def fly():
            pass

    class Duck(Bird):
        pass

    class Ostrich(Bird):
        pass

The above example is a bad implementation, Considering ostriches can't actually fly, We need our subclasses to be able to replace parent classes while still being logically consistent.

    class Bird():
        pass

    class FlyingBirds(Bird):
        def fly():
            pass

    class Duck(FlyingBirds):
        pass

    class Ostrich(Bird):
        pass

The example above is a good implementation of the concept.

Interface Segregation principle

An interface can be imagined as a contract, if you decide to implement an interface, you have to do so in its entirety

So what if you have interfaces with too many functions, all the classes will have
to implement all the functions even if it just needs one or two of them.

class IShape:
    def draw(self):
        raise NotImplementedError

class Circle(IShape):
    def draw(self):
        pass

class Square(IShape):
    def draw(self):
        pass

class Rectangle(IShape):
    def draw(self):
        pass

You can implement multiple interfaces, so its better to have smaller and more specific interfaces.

Dependency Injection principle

Imagine a scenario where you're directly instantiating classes into other classes. Everytime a class needs to be instantiated, all the classes that its dependent on will need to be instantiated as well, incurring a massive overhead.

This is solvable by simply giving the responsinbility of instantiation of objects to another entity.

class AuthenticationForUser():
    def __init__(self, connector:Connector):
        self.connection = connector.connect()

    def authenticate(self, credentials):
        pass
    def is_authenticated(self):
        pass    
    def last_login(self):
        pass

class AnonymousAuth(AuthenticationForUser):
    pass

class GithubAuth(AuthenticationForUser):
    def last_login(self):
        pass

class FacebookAuth(AuthenticationForUser):
    pass

class Permissions()
    def __init__(self, auth: AuthenticationForUser)
        self.auth = auth #Object is injected here.

    def has_permissions():
        pass

class IsLoggedInPermissions (Permissions):
    def last_login():
        return auth.last_log

The AuthenticationForUser object is passed into the constructor instead of being instantiated inside the class

Database management systems

Utsav — Fri, 12 May 2023 12:42:02 +0000

Introduction

DBMS is perhaps one of the most important concepts that every back-end engineer needs to have a reasonable level of mastery of. This paper aims to help readers understand all the basic concepts, We won't touch on the details considering there is a lot to cover here, But i'll try to make it comprehensive

Transactions

Transactions are a series of logically related operations. They are a fundamental part of DBMS.

Operations involving transactions:

Read operation: This operation is used to read data from the database and store it in the buffer memory
Write operation: This operation is used to write data to the database from the buffer.
Commit: This operation is used to save the work done permanently
Rollback: Used to rollback the work done, in case of failures.

ACID Properties

This is an important principle if you want to have a robust database.

Atomicity

One transaction must occur in its entirety, if the transaction fails, No changes should be reflected in the database. It should either be a complete success or a complete failure.

Consistency

The changes must remain consistent throughout the database, i.e. the data must remain correct after the transaction.

Isolation

Every transaction must be independent of other concurrent transactions, It can be a huge problem if transactions are allowed to interfere with each other.

Durability

This property ensures that the data in the database perists even after system failures.

CAP Theorem

This theorem is used by system desginers working with distributed systems to manage trade offs while desgining shared-data systems(over networks). The theorem states that it is not possible to guarantee all three desriable properties from a distributed system. It consists of three properties:

Consistency: Please do not confuse this consistency with the one in ACID properties, consistency in this context refers to maintaining the consistency of all copies of the database across all nodes in the distrubuted system.
Availability: This property means that the database should always be available for operations and all nodes in the network should be able to respond in reasonable time.
Partition Tolerance: Partition tolerance can be applied over a network if the nodes are separated into clusters (It's kind of like strongly connected components in a graph), So when a fault occurs in a cluster, the outage is restricted to that cluster.

Joins

Joins are used in SQL when you require data from two tables. Let me demonstrate with an example:

Let's say you need permanent address and bank account details of an employee, but they're located in two different tables, here you'd need to join the two tables.

You'll start to realise you need some common attribute for these employees to connect these two tables, It can't be names because two people can have the same names, it needs to be something that is guaranteed to be unique for all employees. Here comes the concept of primary keys and foreign keys. If you have a number that is unique for all records, you can use that attribute to match the records from the two tables and get the desired attributes. Now, lets get into joins, there's all kinds of them.

Inner join: Essentially gets all the data that's common for both of the tables, discards everything else.

Left join: Gets all the data from the table that's been joined on and the data that's common for both.

Right join: The opposite of the left join.

Outer join: Gets everything

Aggregation functions

Aggregate functions are usually used in conjunction with the group by clause. It applies the function on fields based on the attributes mentioned in the group by clause. For example

    SELECT employees, sum(transactions) AS revenue
    FROM profits GROUP BY employees

The query above will get the sum of transactions for each employee, which in turn tells you the total amount of revenue brought in by every single employee.

count(): this function aggregates the count of an attribute.
sum(): gets the sum of attributes
avg(): gets the average of given attributes
max(): gets the max of given attributes
min(): gets the min of given attributes.

Normalizations

This property defines constraints for the database to follow in order to make it more robust, fault tolerant and accurate. There are a lot of normal forms but we'll only go through the ones that are practically used.

First Normal Form: Requires the tables to have primary keys, so each record can be identified uniquely and every column should have a unique as well.

Second Normal Form: First normal form eliminates repeated data, this normal form deals with redundancies, there's a fine distinction between the two.

ID	Course	Fee
1	C1	199
2	C2	299
3	C1	199

In the table above, ID is the primary key, but the attribute Fee is directly dependent on the course, not the primary key of the table, you can see "199" appearing twice, this is the redundancy that the second normal form aims to eliminate.

ID	Course
1	C1
2	C2
3	C1

Course	Fee
C1	199
C2	299

This would be the state of the table after applying the second normal form.

Third Normal Form: In the example above, The Fee attribute had a transitive dependency on the course attribute, our example eliminates that as well.

Indexes

Indexes are special lookup tables that databases use to speed up data retrieval. They're automatically created for primary and unique key constraints.

In the background, the working of indexing is quite complex so we won't get into too much detail here, Let's scratch the surface:

Indexes are essentially a data structure designed for faster data retrieval, it involves a key and a reference to the data. There are multiple types of indexing methods, we'll discuss the primary indexes here;

Primary Index: The indexes created on the basis of primary key constraints, these indexes are automatically created and require no explicit invocation.

Locking mechanisms

Locking mechanisms are crucial for concurrency control.

Concurrency control: Essentially means that concurrent transactions must not interfere with each other. It can be hard to maintain consistency and integrity if you don't have mechanisms in place to protect transactions.

Now let's talk about different locking protocols:

Simplistic Locks: This mechanism locks the data that is being operated on, the lock is released when the transaction is complete.

Pre-Claiming Locks: This mechanism lists out all the data that needs to be operated on, and requests the database for locks on that data, If the locks are granted, the transaction will proceed, otherwise it will wait until the locks are granted.

Two-Phase Locks: This mechanism divides the process into two phases of Aquiring and releasing locks.

Growing phase: In the growing phase, the transaction only acquires locks on data items but cannot release locks.
Shrinking phase: In this phase, the transaction may release locks, but no new locks can be acquired.

Database Isolation Levels

Isolation levels are essentially levels of strictness by which isolation is enforced by the system.

Lets look at some levels in the order of their strictness:

Read Uncommited: This is the lowest level, Concurrent transactions can read uncommited changes by other ongoing transactions.

Read Commited: In this isolation level, the transactions can only read the commited changes by other transactions.

Repeatable Read: This level is mostly isolated but phantom reads are still possible, i.e. if the transaction calls the read operation twice and a commited transaction happens in between those calls, The output of the two queries can differ.

Serilizable: This is completely isolated, the transactions read like they were serialized.

Triggers

A trigger is a stored procedure that is invoked when a special event occurs, this "special event" can be defined by the user. Let's look at an example:

create trigger stud_marks 
before INSERT 
on 
Student 
for each row 
set Student.total = Student.subj1 + Student.subj2 + Student.subj3, Student.per = Student.total * 60 / 100;

Above SQL statement will create a trigger in the student database so that, whenever marks are entered before inserting this data into the database, trigger will compute those two values and insert with the entered values.

Dictionaries in Python

Utsav — Thu, 11 May 2023 07:02:31 +0000

Description

This paper is meant to help readers get familiar with the concepts of dictionaries in python and the methods that go along with them.

Defining a dictionary:

#A dictionary that maps players of a video
#game to their respective high scores
high_scores={"Utsav": 234, "Siddarth": 898}

dictionaries are contained in curly brackets: {}

Using dictionaries to represent complex data structures

Hash map:
One of the most common ways dictionaries in python are used is as a hash map
Hash maps are used to map certain keys to their corresponding values, they're usually used as a way to reduce time complexities of algorithms, However there's a trade-off because they end up increasing the space complexity of the code.

Graphs (Adjacency Lists):
Dictionaries are also used to store Adjacency lists, which are essentially a way to represent graphs, It maps a key to a list of values, where a key represents a node and the subsequent list of values represent all the connected nodes.

graph={ 1: [2,3,4] ,
    2 : [ 6,7 ]
}

Adding an element in a dictionary

Suppose we have to increment the value for 1 in the given dictionary

frequency={}
if 1 not in frequency:
    frequency[1]=1
else:
    frequency[1]+=1

Iterating through a dictionary

The intuitive way

for i in dictionary:
    print(i, dictionary[i])

The way listed above prints the keys and their corresponding values, It's simple and easy to understand especially for people from non python backgrounds.

The pythonic way

for keys,values in dictionary.items():
    print(keys, values)

The .items() function returns a tuple of two elements: (keys, values) . This way is easier on the eyes and looks much more readable. This way of iterating is also in line with the PEP8 standards.

Sorting a dictionary

Dictionaries do not have a .sort() function like lists do in python, but fear not! The gods of programming are not that merciless.

The sorted() function essentially works the same way. However, make sure you pass the dictionaries using the .items() method.

dictionary={1:3,2:2,3:1}
print(sorted(dictionary))
#The code above will sort and print
#The list of keys by default
#output: [1,2,3]
print(sorted(dictionary.items))
#Now that we're passing both items
#output: {1:3,2:2,3:1}

But what if you want to sort this dictionary by it's values instead ? Let's take a short detour to lambda functions

fun= lambda x:x+5
#To easiest way to explain this is to
#show you how you can achieve this
#without lambda
def fun(x):
    return x+5

These functions save us from needing to type out small functions that will never be used again, do not use lambda if you need to type it out a lot of times in your code, Make it a separate function instead. Now let's get back to where we were:

dictionary={1:3,2:2,3:1}
ans=sorted(dictionary.items(), key= lamda x: x[1]) 
print(ans) #output: {3:1,2:2,1:3}

since .items() returns a tuple of key value pairs, specifying x[1] notifies the function that the dictionary needs to be values.

Miscellaneous functions

.update(): This function is used in between dictionaries, let's say you have a current_dictionary and an updated_dictionary , if you want to update the values in your current dictionary using the corresponding keys in the new dictionary, you can use this function.

current_dictionary.update(new_dictionary)

.pop(): This function removes elements from a dictionary based on the keys provided.

age={"utsav":23, "siddarth":6}
age.pop("siddarth")
print(age) #output: {"utsav":23}

The function above removes items in dictionary based on their keys

Object Oriented Programming

Utsav — Thu, 11 May 2023 06:52:29 +0000

Introduction

The aim of this paper is to help the reader get familiar with the concepts of object oriented programming , syntax for demonstrations will be in Python.

Basic Concepts

Polymorphism: This concept can be broken down into two different categories, Run time polymorphism and Compile time polymorphism, However, The basic gist of the concept is that a function can behave differently given different circumstances, Python does not support compile time polymorphism. so we'll just look at some examples for run time polymorphism.

class Parent():
    def __init__(self):
        pass
    def show(self):
        print("This is parent class")

class Child(Parent):
    def __init__(self):
        pass
    def show(self):
        super().show()
        print("This is child class")


child=Child()
parent=Parent()
child.show()

In the example above, The show method in the child class overrides the show method derived from the parent class. However, if you still wish to use the parent method, you can use the super() method as shown in the example. It instead invokes the overriden function.

Encapsulation: This is the idea of wrapping data and the methods that work on data within one unit. When you look at the definitions of Encapsulation and Data Hiding online, you might find a lot of redundancies for the explanations of these two concepts. We'll just talk about encapsulation here.

class getArea():
    def __init__(self):
        self.length=0
        self.breadth=0

    def set_sides(self,l,b):
        self.length=l
        self.breadth=b

    def get_area(self):
        return self.length*self.breadth

The above snippet is a good example of encapsulation, bundling up all variables and functions inside a single unit.

Data Hiding: We talked about Encapsulation before, the gist of this concept is similar. This concept deals with the security of the software. Let me demonstrate with an example.

class User():
    def __init__(self):
        self.username="Utsav"
        self.password="xwru3"

The example above demonstrates the dangers of not hiding data that needs to stay secret, since the username and password in the above snippet are public variables anyone can change them. Let me demonstrate a better way of doing this:

class User():
    def __init__(self):
        self.__username="Utsav"
        self.__password="xwru3"
    def change_password(self,new_password,old_password):
        if old_password!=self.__password:
            print("The password you entered is incorrect")
            return
        self.__password=new_password
        print("Password changed successfully")

The code above demonstrates how you can increase security using private methods when needed. Now you can only change the password if you know your old password.

Abstraction: This is the concept of only displaying the essential details to the user.

from abc import ABC, abstractmethod   
class Car(ABC):   
    def mileage(self):   
        pass  

class Tesla(Car):   
    def mileage(self):   
        print("The mileage is 30kmph")   
class Suzuki(Car):   
    def mileage(self):   
        print("The mileage is 25kmph ")   
class Duster(Car):   
    def mileage(self):   
          print("The mileage is 24kmph ")   
class Renault(Car):   
    def mileage(self):   
        print("The mileage is 27kmph ")

The class Car above is a generic class with no implementation of its functions, its essentially a skeleton class that gives out the structure of the class.

Inheritance

Now lets talk about one of the most important concepts in OOP, inheriting different classes functionalities into your own class. There are a lot of different kinds of functionalities

Simple Inheritance: Simply inheriting a single class into your own.
Example:

class parent():
    def show():
        print("parent")
class child(parent):
    def showchild():
        print("child")

This is a pretty straight forward example of inheritance, one class inheriting another class.

Multilevel Inheritance: You can layer inheritance as well, let me demonstrate:

class GrandParent():
    def show():
        print("This is the grandparent)
class Parent(GrandParent):
    def show():
        print("This is the parent")
class Child(Parent):
    def show():
        print("This is the child")

See? you can chain inheritance as much as you want.

Hierarchical Inheritance: You can inherit a class multiple times:

class Dad():
    def show():
        print("this is dad")
class Son(Dad):
    def show():
        print("this is son")
class daughter(Dad):
    def show():
        print("this is daughter")

Multiple children can inherit the same parent.

Multiple Inheritance: Kind of the opposite of Hierarchical Inheritance. Let me demonstrate:

class Dad():
    def show():
        print("this is dad")
class Mom():
    def show():
        print("This is mom")
class Child(Dad,Mom):
    def show():
        super().show()
        print("This is child")

A child can inherit two classes, However you should be familiar with the Method Resolution order when you're working with this. The order is how you inherit the classes, here class X(Y,Z), Y will take precedence over Z in the order.

Static Variables

Python doesn't have a static keyword, but that doesn't mean we can't have static variables, the trick is to define the variable outside of any function, without using the self attribute, self is used to define instance variables.

class X():
    static_var=0
    def __init__(self):
        self.not_static_var=0

Here, The static_var variable will behave just like a static variable in any other language.
Static variables are the same for all objects, They belong to the class, if you change this variable in an object, the change will be reflected for all other objects.

String Methods

Utsav — Thu, 11 May 2023 05:42:44 +0000

Introduction

The aim of this paper is to help the reader get familiar with the standard functions of strings in Python.
Functions

1 . .count(): This function returns the count of a specific value inside a string , the value is passed as an argument. Syntax:

    s="aabbzzz"
    character_to_be_counted='z'
    frequency=s.count(character_to_be_counted) #This is the generic syntax
    print(frequency)

The snippet above prints the number of time "z" appears in the string "s" which is 3

2 . .find() and .index(): The reason I have grouped these two together is because they serve almost the same functionality, both of these functions will return the first index of where a specified value is found , however when they fail to find the value, .index() raises a ValueError exception and .find() returns -1. Syntax:

    s="aabbcc"
    answer=s.find("a")
    answer2=s.index("a")
    print(answer,answer2)

Both of these functions will return 0 (The first occurrence of "a")

3 . .format(): This function places text inside given string, The user needs to define a placeholder inside the string so the function knows where to place specific values. Syntax:

    text="The price of {fruit} is {price}"
    modified_string=text.format(fruit="mango",price=35")
    print(modified_string)

The output for the snippet above is The price of mango is 35
format maps the values to their respective placeholders.

4 . .isalpha(): This function returns a boolean value after checking if all characters in a string are alphabets or not. Syntax:

    text1="Company"
    text2="Company10"
    check_alpha1=text1.isalpha()
    check_alpha2=text2.isalpha()
    print(check_alpha1,check_alpha2)

The above snippet prints True and False respectively.

5 . .replace: This function replaces a given character or a phrase with another one. An optional argument can be added , specifying the number of existing phrases the user wants to remove. Syntax:

    text="I like Bananas"
    current_phrase="Bananas"
    new_phrase="Oranges"
    modified_text=text.replace(current_phrase,new_phrase) #This is the generic syntax
    print(modified_text)

6 . .upper() and .lower(): Both of these functions have similar functionality, .upper() changes all characters in a string to uppercase and .lower() changes all the characters to lowercase. Syntax:

    text="AaAbC"
    upper_text=text.upper()
    lower_text=text.lower()
    print(upper_text,lower_text)

The snippet above prints AAABC and aaabc respectively.

7 . .split(): This function splits the string on the basis of the given argument which is space by default. Syntax:

    text1="This is a sentence"
    new_list=text1.split()
    print(new_list)

The above snippet will print ["This","is","a","sentence"] splitting the above string by space

8 . .strip(): This function removes the leading and trailing occurrences of a specified string, the default argument is space. Syntax:

    text1="  abcd    "
    new_text1=text1.strip()
    print(new_text1)

The above snippet will print abcd removing all instances of spaces from the right and the left end.

9 . .join(): This function is the polar opposite of the .split() function , This function will help you out if you want to join a list to make a string based on a separator. Syntax:

    list=["This","is","a","sentence"]
    separator="  "
    answer=separator.join(list)
    print(answer)

The snippet above will print This is a sentence creating a space will adding the specified separator between the words.

10 . isdigit(): Returns True if all characters in the given string are digits , else returns False. Syntax:

    digit="10273"
    non_digit="adefre13"
    print(digit.isdigit())
    print(non_digit.isdigit())

The snippet above prints True and False respectively.

List Methods

Utsav — Tue, 09 May 2023 14:40:07 +0000

Introduction

The aim of this paper is to help the reader get familiar with the standard functions of lists in Python.
Functions

.append() : This function adds an element at the end of the list, since Python allows the user to add multiple data types to the same list, you can append an element of any data type without any errors. Syntax:
```
    list=[1,3]
    new_element=3
    list.append(new_element) #This is the generic syntax
    print(list)
```
- The output for the snippet above will be [1,3,3]
.clear() : This function will remove all elements from the list, be careful while using it. Syntax:
```
    list=[1,2,3]
    list.clear() #This is the generic syntax
    print(list)
```
- The output for the snippet above will be [] (Empty list)
.copy() : This function will simply return a copy of a list. Syntax:
```
    old_list=[1,2,3]
    new_list=old_list.copy() #This is the generic syntax
    print(new_list)
```
- The output for the code above will be [1,2,3]
.count(): Returns the frequency of a given element that is passed as an argument. Syntax:
```
    list=[1,1,1,4]
    element_to_be_counted=1
    frequency=list.count(element_to_be_counted) #This is the generic syntax.
    print(frequency)
```
- The output for the snippet above will be 3 (The number of time 1 appears in the list)
.extend(): This function essentially concatenates one list with another. Syntax:
```
    list1=[1,2,3]
    list2=[4,5,6]
    list1.extend(list2) # This is the generic syntax
    print(list1)
```
- The output for the code above will be [1,2,3,4,5,6]
.index(): Returns the first index of the element that's passed in the argument. Syntax
```
 list1=[1,2,3,3,3,4]
 index=list1.index(3)
 print(index)
```
- The snippet above will print: 2 (The first "3" appears in the list)
.insert(): This function will help you out if you want to place a certain element at a certain index, but be careful because it will obviously shift the indexes of all subsequent elements by "1". Syntax:
```
list=[1,2,3,4]
index=1
element=6
list.insert(index,element) #This is the generic syntax.
print(list)
```
-The above snippet will add 6 at index 1. The output will be:[1,6,2,3,4]
.pop(): This function will remove an element from a specified index, however the argument is optional, The default value is -1 , which means the function will remove the last element by default. Syntax:
```
list=[1,2,3,4]
index_to_be_removed=2
list.pop(index_to_be_removed) #This is the generic syntax
print(list)
```
- The output for the above snippet is: [1,2,4]
  
  list.pop()

The code above will further remove the last element , Output: [1,2]

9 . .remove(): This function has the similar functionality as .pop() but this function removes by value instead of index, This removes the first occurrence of the specified value. Syntax:

    list=[1,2,2,2,3,4]
    element_to_be_removed=2
    list.remove(element_to_be_removed) #This is the generic syntax
    print(list)

The output for the above code will be: [1,2,2,3,4]

10 . .reverse(): This function will simply reverse the given list. Syntax

    list=[1,2,3,4,5]
    list.reverse() #This is the generic syntax.
    print(list)

The output for the snippet above will be: [5,4,3,2,1]

11 . .sort(): This function will sort the given list,It sorts by ascending order by default , However you can specify the order as an optional argument. You can also customize this function by specifying a key according to which you want the function to sort the elements. Syntax:

           list=[3,4,2,1,5]
           list.sort() #This is the generic syntax
           print(list)

The snippet above will sort the list by ascending order, Output: [1,2,3,4,5]
```
    list.sort(reverse=True)
    print(list)
```

The snippet above will sort the list by descending order, Output: [5,4,3,2,1]

    def function(s):
        return len(s)
    list=["aaaa", "bb" , "c"]
    list.sort(key=function)
    print(list)

The code above will sort the list of strings by their lengths instead of their lexicographical order.

List as stacks

Stacks follow the Last In First Out (LIFO) structure, files are appended and popped from the same location, they are used to track "states" in algorithms, but that's a topic for another paper.

stack=[1,2,3,4]
def push(x):
    stack.append(x)
def pop():
    return stack.pop()

This successfully emulates the concept of stacks

List as queues

We can emulate queues using lists as well, queues follow the First In First Out (FIFO) structure.

queue=[1,2,3,4]
def push(x):
    queue.append(x)
def pop():
    return queue.pop(0)

.pop(0) removes the first element, successfully imitating the concept of queues