DEV Community: Tejeswararao123

Django

Tejeswararao123 — Tue, 04 Apr 2023 12:55:01 +0000

Settings File:

The settings.py file is a Python module that stores various configuration settings for your Django project, such as database settings, time zones, installed apps, middleware, templates, and more. You can access these settings in your code using the django.conf.settings object. It is important to configure the settings.py file correctly to ensure that your Django project runs smoothly.

Secret Key:

The SECRET_KEY is a randomly generated string of characters that is used to secure your Django project. It is used to sign cookies, create CSRF tokens, and other cryptographic functions. The SECRET_KEY should be kept secret and never shared with anyone. To generate a new secret key, you can use the django.core.management.utils.get_random_secret_key() function.

Default Django Apps:

Django comes with several built-in apps that are included in the INSTALLED_APPS list in the settings.py file. These apps include django.contrib.admin, django.contrib.auth, django.contrib.contenttypes, django.contrib.sessions, django.contrib.messages, and django.contrib.staticfiles. These apps provide functionality such as user authentication, database migrations, session management, message passing, and static file serving. You can also add your own custom apps to this list.

django.contrib.admin:

This app provides an admin interface to manage Django applications. It includes features like adding/editing/deleting records, search, and filters.

django.contrib.auth:

This app provides user authentication features like login, logout, and password management.

django.contrib.contenttypes:

This app provides content types and framework for associating metadata with models.

django.contrib.sessions:

This app provides session management features for the web application.

django.contrib.messages:

This app provides messaging features for the web application.

django.contrib.staticfiles:

This app provides a framework for managing static files like CSS, JavaScript, and images.

django.contrib.humanize:

This app provides various filters to make data more human-readable, such as formatting dates, times, and numbers.

django.contrib.sites:

This app provides a framework for managing multiple sites in a single Django installation.

django.contrib.redirects:

This app provides a framework for managing URL redirects.

django.contrib.sitemaps:

This app provides a framework for creating sitemaps for search engines.

django.contrib.syndication:

This app provides a framework for creating syndication feeds.

Middleware:

Middleware is a framework that allows you to process HTTP requests and responses in Django. It sits between the web server and Django framework and can perform various tasks such as modifying requests and responses, adding or removing headers, and executing additional code before or after the view function is called. Middleware is added to the MIDDLEWARE list in the settings.py file and is executed in the order they are listed.

Different Kinds of Middleware:

There are several kinds of middleware in Django, including:

Authentication Middleware - This middleware handles user authentication by verifying the user's credentials and setting the request.user attribute. It is responsible for identifying the user making the request and allowing or denying access to resources based on the user's permissions.
Session Middleware - This middleware provides a way to store user data between requests. It is responsible for creating a unique session ID for each user and storing the user's data in the session object.
CSRF Middleware - This middleware provides protection against Cross-Site Request Forgery (CSRF) attacks. It generates a unique token for each request and ensures that the token is included in any POST requests. This helps prevent attackers from submitting unauthorized requests to your application.
CommonMiddleware - This middleware provides a range of commonly used middleware functionality. It includes URL redirection, response caching, and gzip compression. For example, it automatically redirects requests for URLs that end with a slash to the same URL without the slash.
SecurityMiddleware - This middleware adds security features to your Django application. It includes Content Security Policy (CSP), XSS protection, and HSTS. CSP allows you to define a policy for how resources are loaded on your web page, while XSS protection helps prevent Cross-Site Scripting (XSS) attacks. HSTS ensures that your website is always accessed over HTTPS.

Django Security:

Django has several built-in security features to help protect your web application against common web attacks such as SQL injection, Cross-Site Scripting (XSS), and CSRF. Some of these features include automatic SQL injection protection through QuerySet parameterization, protection against XSS by automatically escaping HTML in templates, and protection against CSRF via the CsrfViewMiddleware.

CSRF:

Cross-Site Request Forgery (CSRF) is a type of web attack that tricks a user into performing an action on a website without their knowledge or consent. Django protects against CSRF attacks by using a CSRF token, which is a unique value generated for each session and included in the HTML form as a hidden input. When the form is submitted, the token is verified to ensure that the request was made by the same user.

XSS:

Cross-Site Scripting (XSS) is a type of web attack that allows attackers to inject malicious scripts into web pages viewed by other users. These scripts can be used to steal sensitive information, modify web page content, or perform other malicious actions. To prevent XSS attacks, Django automatically escapes HTML in templates, so that any user-generated content is displayed as plain text.

Clickjacking:

Clickjacking is a type of web attack that tricks users into clicking on a button or link on a web page without their knowledge or consent. This can be done by overlaying a transparent layer on top of a legitimate website and placing a fake button or link on the layer. To prevent clickjacking attacks, Django includes the X-Frame-Options header in responses, which instructs web browsers to prevent the page from being loaded in an iframe.

Other Middleware:

Django has several other built-in middleware, such as GZipMiddleware, which compresses responses to reduce bandwidth usage, ConditionalGetMiddleware, which adds support for HTTP conditional requests, and LocaleMiddleware, which sets the language code for the current request based on the user's browser preferences or a URL parameter.

Message Middleware - This middleware adds a message framework that allows one-time messages to be stored and displayed to the user. This is useful for displaying notifications, warnings, or error messages to the user.
Middleware for Debugging - These middleware are used for debugging purposes, such as DebugToolbarMiddleware, which adds a toolbar that displays debugging information for the current page. This middleware is only intended for use in development and should not be used in production.
Third-party Middleware - These are middleware provided by third-party packages that can be added to your Django application for additional functionality. For example, django-cors-headers provides Cross-Origin Resource Sharing (CORS) support, which allows your Django application to make requests to other domains.

Overall, middleware is a powerful tool in Django that allows you to add functionality to your application without modifying the underlying code. By using middleware, you can keep your code clean and maintainable while still adding important features to your application.

WSGI:

Web Server Gateway Interface (WSGI) is a specification that defines a standard interface between web servers and web applications or frameworks. It allows web servers to communicate with web applications in a standardized way, so that different web servers and web applications can be combined easily. Django includes a WSGI application object that can be used to interface with any WSGI-compatible web server.

Models File:

The models.py file is a Python module that defines the structure of the database tables used by your Django application. It contains classes that inherit from the django.db.models.Model class and define the fields and relationships between objects. Models are used to interact with the database, allowing you to create, read, update, and delete objects in the database using Python code. The models.py file is an essential part of a Django application and is used to represent the data of the application.

Ondelete Cascade:

In Django models, when you define a foreign key relationship between two tables, you can specify what should happen when the referenced object is deleted. on_delete is a parameter you can set when defining a foreign key, and it specifies what action should be taken when the referenced object is deleted. on_delete=CASCADE means that when the referenced object is deleted, all objects that have a foreign key reference to it will also be deleted.

Fields and Validators:

Django provides a wide range of fields and validators that you can use to define your models. Fields represent the various types of data that can be stored in your database, such as CharField, IntegerField, DateField, etc. Validators are used to validate the data that is entered into these fields, ensuring that it meets certain requirements. For example, you can use MaxValueValidator to ensure that an IntegerField does not exceed a certain value.

Python Module vs Python Class:

In Python, a module is a file that contains Python code, while a class is a code template that defines the properties and methods of an object. A module can contain one or more classes, as well as functions, variables, and other Python code. Classes are typically defined in a module, and then imported into other modules or scripts as needed.

Django ORM:

Object-Relational Mapping (ORM) is a technique for accessing and manipulating data stored in a relational database using an object-oriented programming language. Django provides a powerful ORM that allows you to work with your database using Python code, rather than writing SQL directly. The ORM abstracts away many of the details of working with the database, making it easier to write maintainable code.

Using ORM Queries in Django Shell:

The Django shell is an interactive Python console that allows you to interact with your Django application's models and data. You can use ORM queries in the Django shell to retrieve data from your database, update records, or delete records. For example, you can use MyModel.objects.all() to retrieve all records from the MyModel table, or MyModel.objects.get(id=1) to retrieve the record with an id of 1. The Django shell is a powerful tool for exploring and manipulating your data, and is often used during development and debugging.

Turning ORM to SQL in Django Shell:

In Django, you can use the django.db.connection object to directly execute SQL statements against your database. You can use this feature in the Django shell to explore the SQL generated by the ORM. To turn the ORM into SQL, you can call the query method on a Django queryset object. This will return the SQL statement that would be executed by the database backend for the given queryset.

Aggregations:

Aggregations are functions that are used to calculate values over a set of database records. In Django, you can use the aggregation API to perform calculations on your querysets. Aggregations can be used to calculate the sum, average, minimum, or maximum value of a field in your model. Aggregations can be combined with filters and annotations to create complex queries.

Annotations:

Annotations are a way of adding additional calculated fields to your querysets. Annotations allow you to add calculated fields to your queryset that are not part of your model. You can use annotations to calculate the sum, average, or count of related records, or to perform other calculations on your data. Annotations can be combined with filters and aggregations to create complex queries.

Migration Files:

Migration files are generated by Django's built-in migration framework when you make changes to your database schema. Migration files are used to record changes to your models, and are used to keep your database schema in sync with your models. Migration files are Python files that contain a series of operations that are executed when you run the migration. Migration files are stored in the migrations directory of your Django application.

SQL Transactions:

SQL transactions are used to group a series of SQL statements together into a single unit of work. Transactions are used to ensure that a series of SQL statements are executed as a single, atomic operation. Transactions can be used to ensure data consistency and integrity, and can be used to recover from errors or other failures during the execution of SQL statements.

Atomic Transactions:

Atomic transactions are a feature of Django's ORM that allow you to group a series of database operations into a single, atomic transaction. Atomic transactions are similar to SQL transactions, but are implemented at the ORM level. Atomic transactions are used to ensure that a series of database operations are executed as a single, atomic operation. Atomic transactions can be used to ensure data consistency and integrity, and can be used to recover from errors or other failures during the execution of database operations.

Scope, Hoisting and Closures in Javascript

Tejeswararao123 — Sat, 18 Mar 2023 04:05:33 +0000

Scope

Scope in JavaScript refers to the accessibility of variables, functions, and objects in a particular part of the code. JavaScript uses lexical scoping, which means that the scope of a variable or function is determined by its location in the code.
Before getting into scope we have to know how we can declare variables in javascript. There are three methods in javascript to declare variables ie. let var and const.

The variables declared with a var will have function scope. Example

function foo() {
  var a = 1;
  console.log(a);
}

foo(); // Output: 1
console.log(a); // Error: a is not defined

If a variable is declared in a function using var then it can be accessible in the function only but if it is defined in the block it will have block scope it can be accessed anywhere in the program Example

if(2 < 3){
  var a = 1;
  console.log(a);
}

console.log(a); // Output: 1

In javascript nested functions can access variables in their parent function these nested functions are called closures. Example

  function outer() {
  var a = 1;

  function inner() {
    var b = 2;
    console.log(a, b);
  }

  inner();
}

outer(); // Output: 1 2

The variables declared using let and const will have block scope means any variable declared within curly braces cannot accessible from outside of curly braces. Example

if(2 < 3){
  var a = 1;
  console.log(a);
}

console.log(a); // Output: undefined

Nested functions can access variables declared in an outer function
If a variable is declared outside all functions and blocks it will have global scope means it can be accessed from anywhere in the program.

Hoisting

In javascript, execution will have two phases one is the creation and another one is execution. In the creation phase all variables will be created in memory with the default value undefined and all the functions will store fully. Here only variables declared with var and regular functions will be created in the creation phase. This is known as hoisting

In the execution phase variable initialization will take place Example

console.log(hi) // undefined
console.log(hello) // reference error

var hi =90
let hello=99

var hii=44
hi()

function hi(){
    console.log(hii);// output: 44
}

Closures

In JavaScript, a closure is created when a function is defined inside another function and the inner function is returned or passed as a reference to a variable outside its enclosing function. The closure captures and retains the values of all the variables that were in scope at the time of its creation, even after the outer function has returned. Closures allow you to create private variables and functions that are inaccessible from outside the function in which they were defined

Example

function outerFunction(x) {
  function innerFunction(y) {
    return x + y;
  }
  return innerFunction;
}

let addFive = outerFunction(5);
console.log(addFive(3)); // Output: 8

In this example, outerFunction returns innerFunction, which is then assigned to the variable addFive. When addFive is called with an argument of 3, it returns 8. The closure is created when innerFunction is defined inside outerFunction, and it captures the value of x, which is 5. Even though outerFunction has returned and its local variables are no longer in scope, the closure retains the value of x and can still access it when innerFunction is called.

Applications of closures

Private variables and methods: Closures can be used to create private variables and methods that are inaccessible from outside the function in which they were defined. This can be useful for preventing unintended modifications to your code. For example:

function counter() {
  let count = 0;
  function increment() {
    count++;
    console.log(count);
  }
  return increment;
}

let c = counter();
c(); // Output: 1
c(); // Output: 2
c(); // Output: 3

Memoization: Closures can be used to implement memoization, which is a technique for caching the results of expensive function calls to improve performance. For example:

function memoize(func) {
  let cache = {};
  return function(...args) {
    let key = JSON.stringify(args);
    if (cache[key]) {
      console.log('Retrieving from cache');
      return cache[key];
    }
    else {
      console.log('Calculating result');
      let result = func(...args);
      cache[key] = result;
      return result;
    }
  };
}

function fibonacci(n) {
  if (n < 2) return n;
  return fibonacci(n-1) + fibonacci(n-2);
}

let memoizedFibonacci = memoize(fibonacci);
console.log(memoizedFibonacci(10)); // Output: 55
console.log(memoizedFibonacci(10)); // Output: Retrieving from cache, 55

Callback functions: Closures can be used to create callback functions that have access to variables from the parent function. This can be useful for implementing event handlers and other asynchronous operations. For example:

function doSomething(callback) {
  let data = 'hello world';
  setTimeout(function() {
    callback(data);
  }, 1000);
}

function callbackFunction(data) {
  console.log(data.toUpperCase());
}

doSomething(callbackFunction); // Output: HELLO WORLD

HTML and CSS concepts

Tejeswararao123 — Thu, 02 Mar 2023 07:22:43 +0000

Box Model:

Every element on a webpage is considered a rectangular box
Box model has some properties which can be set to the HTML page #### Padding:
Specifies the gap between content and border

// HTML code //

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
  <h1 class="header"> hello</h1>
</body>
</html>


//  CSS code  //
.header{
    padding:1rem;
}

The above maintain a gap of 1rem between content and border of h1 element
Here are some of the padding attributes #### padding-top
Specifies the gap between the top of the content and the border
in the same we can use padding-left, padding-bottom, and padding-right to give space at required position.
If we want to apply the same padding for the top and bottom and the same padding for the left and right you have to pass two values like below

p{
    padding: 1rem 2rem;
}

The above property sets 1rem gap at the top and bottom and a 2 rem gap at the left side and right side
if you want different spacing for all four sides you can give 4 values for the padding attribute

a{
    padding: 1rem 2rem 3rem 2rem;
}

Here the order of values applied to the element is a top, right, bottom, left #### Margin:
margin specifies the gap between the border and other outside sibling elements
Syntax for margin is the same as padding explained above but instead of padding we use margin in syntax
you can use all the attributes mentioned for padding For example

p{
    margin: 10px 20px 22px 10px
}

Border:

Border specifies how the border should be to your HTML elements like border style, border width, and border color.
border-style properties are dashed, solid, none, and dotted
border-width specifies the width of the border
border-color specifies the color of the border
Shorthand syntax to apply all of the above properties is

a{
    border: solid 2px blue
}

Box-sizing in CSS

This property controls how an element's width and height are calculated, including its padding and border.
By default, when you set the width and height of an element in CSS, those values only apply to the element's content
If you apply border and padding the element size will increase because the default value for box-sizing is content-box
If you want to mention sizes including padding and border you can give border-box for box-sizing element Example

.element {
  box-sizing: border-box;
  width: 200px;
  padding: 10px;
  border: 1px solid black;
}

In the above code, the box-sizing property is set to border-box, which means that the element's width of 200 pixels includes its padding and border. Without the border-box value, the element's total width would be 222 pixels (200px + 10px padding on each side + 1px border on each side).

Inline versus Block Elements:

Block elements:

Block elements are those that take up the full width of their container and create a new line after the element.
Block elements typically contain other block and inline elements within them
Examples of block elements include

<div>, <p>, <h1> to <h6>, <ul>, <ol>, and <form>.

inline elements

These elements do not create a new line after the element and only take up as much width as necessary to contain their content.
Examples of inline elements include

<span>, <a>, <strong>, <em>, and <img>.

These elements don't have padding, border, and margin properties

Positioning: Relative/Absolute

position relative

When you set position: relative to an element, it is positioned relative to its normal position on the page.
This means that you can use the top, bottom, left, and right properties to move the element up, down, left, or right from its original position.

.box {
  position: relative;
  top: 20px;
  left: 50px;
}

In this example, the box element will be positioned 20 pixels down from its normal position and 50 pixels to the right of its normal position.

position absolute:

When you set position: absolute on an element, it is positioned relative to its nearest positioned ancestor.
If no ancestor elements are positioned, then the element is positioned relative to the body of the webpage.
This means that you can use top, bottom, left, and right properties to position the element precisely on the page, regardless of where it appears in the HTML document. Example

.box {
  position: absolute;
  top: 100px;
  left: 200px;
}

In this example, the box element will be positioned 100 pixels down from its nearest positioned ancestor and 200 pixels to the right of its nearest positioned ancestor.

Common CSS structural classes:

structural classes are used to apply styles to specific types of elements based on their position in the document tree. #### Parent selector
The parent selector (also known as the "descendant selector") is used to apply styles to child elements based on their relationship to a parent element.
The selector uses a space to indicate the relationship between the parent and child elements. Example

.parent p {
  color: red;
}

In this example, the p elements that are descendants of the parent element will have red text color.

Child Selector

The child selector (also known as the "direct descendant selector") is used to apply styles to direct child elements of a parent element.
The selector uses the > symbol to indicate the direct relationship between the parent and child elements. Example

.parent > p {
  color: red;
}

In this example, only the direct p children of the parent element will have red text color.

Sibling Selector

The sibling selector is used to apply styles to elements that are siblings of another element.
There are two types of sibling selectors: the adjacent sibling selector and the general sibling selector.

The adjacent sibling selector (represented by the + symbol)

selects the first sibling that follows immediately after the first element. Example

h1 + p {
  color: red;
}

In this example, the p element that immediately follows the h1 element will have red text color.

The general sibling selector (represented by the ~ symbol):

Selects all siblings that follow after the first element.

h1 ~ p {
  color: red;
}

In this example, all p elements that follow the h1 element will have red text color.

pseudo-classes

These are used to style elements based on their state or relationship to other elements in the document tree.
Pseudo-classes start with a colon (:) and are appended to a selector. Common types of pseudo-classes #### :hover *:hover pseudo-class is used to apply styles to an element when the user hovers over it with the mouse.
commonly used to highlight links and buttons. Example

a:hover {
  color: red;
}

This will make all links turn red when the user hovers over them.

:active

: active pseudo-class is used to apply styles to an element while it is being clicked or activated.

button:active {
  background-color: gray;
}

This will make a button turn gray while the user is clicking on it.

:focus

This is used to apply styles to an element that has focus.
commonly used to highlight form fields that are being filled out by the user.

input:focus {
  outline: none;
  border-color: blue;
}

This will remove the outline and change the border color of an input field when it has focus.

:first-child and :last-child

The :first-child and :last-child pseudo-classes are used to select the first or last child element of a parent element.
This is commonly used to style list items or table rows. Example

li:first-child {
  font-weight: bold;
}

tr:last-child {
  background-color: gray;
}

This will make the first list item bold and give the last table row a gray background color.

:nth-child()

The :nth-child() pseudo-class is used to select an element based on its position in the document tree. This is commonly used to alternate the styles of table rows or to select specific items in a list.

For example:

tr:nth-child(even) {
  background-color: gray;
}

li:nth-child(3n) {
  font-style: italic;
}

This will give every even table row a gray background color and make every third list item italic.

You can use odd to select every nth odd element
To select a specific nth child use the below syntax

li:nth-child(3) {
  font-weight: bold;
}

This will select the third li element and make its text bold.

If you want to select every third child element starting from the fourth element use below one

li:nth-child(3n+4) {
  text-decoration: underline;
}

This will select every third li element starting from the fourth li element and underline its text.

Common CSS styling classes

CSS styling classes are reusable sets of styles that can be applied to HTML elements to quickly and consistently achieve a desired visual effect. #### .container
The .container class is used to define a fixed-width container element that centers its content horizontally on the page.
This class is commonly used for wrapping entire page layouts or individual sections of a page.

.container {
  max-width: 1200px;
  margin: 0 auto;
  padding: 0 20px;
}

.btn

This class is used to define a button element with a standardized appearance.

.btn {
  display: inline-block;
  padding: 10px 20px;
  background-color: #007bff;
  color: #fff;
  border-radius: 4px;
  text-decoration: none;
}

.card

This class is used to define a rectangular container element with a border and padding.
It is commonly used for displaying content in a structured and visually appealing way.

.card {
  border: 1px solid #ccc;
  border-radius: 4px;
  padding: 20px;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

The .card class is used to define a rectangular container element with a border and padding

.form-control

This class is used to define form input elements with a standardized appearance.
It is commonly used for text inputs, text areas, and other form elements.

text-center

This class is used to horizontally center text inside an element.
It is commonly used for headings, paragraphs, and other text elements.

.text-center {
  text-align: center;
}

.split { float: left; width: 50%; }
.center { text-align: center: margin: auto; display: block; }
.bold { font-weight: bold; }
.top { vertical-align: top; }
.bottom { vertical-align: bottom; }

By defining common style attributes you can re-use whenever you need.

CSS Specificity

CSS specificity is a way of determining which CSS rules should be applied to an HTML element when there are multiple CSS rules targeting the same element.

below is the order of specificity from lowest to highest

Type selectors (e.g., div, p, a)
Class selectors (e.g., .my-class)
ID selectors (e.g., #my-id)
Inline styles (e.g., style="color: red;")

The higher the specificity of a selector, the more weight it carries when determining which CSS rule should be applied to an element. For example, a rule with an ID selector will override a rule with a class selector, which in turn will override a rule with a type selector.

CSS Responsive Queries

To make our webpage responsive we use media queries
Media queries allow developers to apply different styles to different devices or screen sizes based on their characteristics, such as screen width, height, orientation, resolution, and more.
To use media queries in CSS, you can add them to your CSS stylesheet using the @media rule.
Example

/* styles for all devices */
body {
  font-size: 16px;
  color: #333;
}

/* styles for devices with a maximum width of 768px */
@media (max-width: 768px) {
  body {
    font-size: 14px;
  }
}

/* styles for devices with a minimum width of 1024px */
@media (min-width: 1024px) {
  body {
    font-size: 18px;
  }
}

In the example above, we have defined styles for all devices by targeting the body element. Then, we added two media queries to adjust the font size of the body element based on the device's screen width. The first media query targets devices with a maximum width of 768px, and the second targets devices with a minimum width of 1024px.

Media queries can also be combined with logical operators (and, not, and only) and other CSS selectors to create more complex rules.
Example:

/* styles for devices with a width between 768px and 1023px */
@media (min-width: 768px) and (max-width: 1023px) {
  .container {
    width: 90%;
  }
}

/* styles for devices with a width greater than 1024px or with a high-resolution display */
@media (min-width: 1024px) or (orientation: protrait) {
  .container {
    width: 80%;
  }
}

Flexbox/Grid

Flexbox

Flexbox (short for "Flexible Box Layout") is a layout model in CSS that allows you to create flexible and responsive layouts for web pages.

It provides a way to arrange and align elements inside a container, regardless of their size or content, in a predictable and flexible way.

display:

This property sets the element to be a flex container or not. To create a flex container, set the display property to flex or inline-flex.

flex-direction:

This property sets the direction of the main axis of the flex container. It can be set to row (left-to-right), row-reverse (right-to-left), column (top-to-bottom), or column-reverse (bottom-to-top).

justify-content:

This property sets the alignment of flex items along the main axis of the flex container. It can be set to flex-start (left or top), flex-end (right or bottom), center (centered), space-between (distributed evenly with no extra space before the first or after the last item), space-around (distributed evenly with equal space before the first and after the last item), or space-evenly (distributed evenly with equal space between all items).

align-items:

This property sets the alignment of flex items along the cross-axis of the flex container. It can be set to stretch (stretches to fill the container), flex-start (top or left), flex-end (bottom or right), center (centered), or baseline (aligned on their baselines).

flex-wrap:

This property determines whether flex items should wrap or not if they exceed the width or height of the flex container. It can be set to nowrap (no wrapping), wrap (wrapping if needed), or wrap-reverse (wrapping in reverse order).

align-content:

This property sets the alignment of multiple lines of flex items along the cross-axis of the flex container. It works like justify-content, but for multiple lines of flex items. It can be set to stretch (stretches to fill the container), flex-start (top or left), flex-end (bottom or right), center (centered), space-between (distributed evenly with no extra space before the first or after the last line), space-around (distributed evenly with equal space before the first and after the last line), or space-evenly (distributed evenly with equal space between all lines).

flex:

This property is a shorthand for setting the flex-grow, flex-shrink, and flex-basis properties.
It sets how much a flex item should grow or shrink relative to the other flex items in the same container. Example Html code

<div class="flex-container">
  <div class="flex-item">1</div>
  <div class="flex-item">2</div>
  <div class="flex-item">3</div>
  <div class="flex-item">4</div>
</div>

CSS code

.flex-container {
  display: flex;
  flex-wrap: wrap;
  justify-content: space-between;
  align-items: center;
  align-content: center;
  height: 400px;
  background-color: lightblue;
}

.flex-item {
  flex: 1 1 100px;
  background-color: white;
  color: black;
  font-size: 24px;
  text-align: center;
  padding: 20px;
  margin: 10px;
}

Grid

CSS Grid is a powerful layout system that allows you to create complex two-dimensional layouts for web pages.

display: grid;:

This property is used to make an element a grid container.

grid-template-columns and grid-template-rows:

These properties are used to define the size of the grid tracks (rows and columns) in the grid. They can accept values such as length, percentage, fr units, auto, and minmax().

Example

.container {
  grid-template-columns: 1fr 1fr 1fr;
  grid-template-rows: 100px 200px;
}

grid-template-areas:

This property is used to define the grid areas by specifying the grid names for each cell in the grid. You can use dots to represent empty cells. Example

.container {
  grid-template-areas: 
    "header header header"
    "nav main aside"
    "footer footer footer";
}

grid-template:

This is a shorthand property that combines grid-template-rows, grid-template-columns, and grid-template-areas in one declaration.

grid-column-gap and grid-row-gap:

These properties are used to define the space between grid columns and rows.

.container {
  grid-column-gap: 10px;
  grid-row-gap: 20px;
}

grid-gap:

This is a shorthand property that combines grid-row-gap and grid-column-gap in one declaration.

.container {
  grid-gap: 10px 20px;
}

grid-auto-rows and grid-auto-columns:

These properties are used to set the size of the rows and columns that are not explicitly defined in the grid template.

.container {
  grid-auto-rows: 200px;
  grid-auto-columns: 1fr;
}

grid-auto-flow:

This property is used to specify how the grid should fill in cells that are not explicitly defined in the grid template. The possible values are row, column, row dense, and column dense.

.container {
  grid-auto-flow: row;
}

grid:

This is a shorthand property that combines grid-template-rows, grid-template-columns, grid-template-areas, grid-auto-rows, grid-auto-columns, and grid-auto-flow in one declaration.

.container {
  grid:
    "header header header" 100px
    "nav main aside" 1fr
    "footer footer footer" 100px /
    1fr 2fr 1fr;
}

grid-row-start, grid-row-end, grid-column-start, and grid-column-end:

These properties are used to specify the starting and ending positions of grid items in the grid.

.item {
  grid-row-start: 2;
  grid-row-end: 4;
  grid-column-start: 2;
  grid-column-end: 4;
}

grid-row and grid-column:

These are shorthand properties that combine grid-row-start, grid-row-end, grid-column-start, and grid-column-end in one declaration.
Example

.item {
  grid-row: 2 / 4;
  grid-column: 2 / 4;
}

grid-area:

This property is used to specify the grid area that a grid item should span.

.item {
  grid-area: 2 / 2 / 4 / 4;
}

justify-items and align-items:

These properties are used to align grid items within their grid cells. The possible values are start, end, center, stretch, and baseline. Example code

.container {
  justify-items: center;
  align-items: end;
}

justify-content and align-content:

These properties are used to align the grid tracks within the grid container. The possible values are start, end, center, stretch, space-between, space-around, and space-evenly.

Example

.container {
  justify-content: space-between;
  align-content: center;
}

place-items and place-content:

These are shorthand properties that combine justify-items and align-items, and justify-content and align-content in one declaration.

.container {
  place-items: center end;
  place-content: space-between center;
}

grid-auto-flow:

This property controls the automatic placement of grid items that are not explicitly placed with grid-row and grid-column. Example

.container {
  grid-auto-flow: dense;
}

Common header meta tags

<meta charset="utf-8">

This meta tag specifies the character encoding used in the document, which is usually set to UTF-8.

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

This meta tag sets the viewport size for the document, which is important for responsive design. The width=device-width attribute sets the width of the viewport to the width of the device, while the initial-scale=1.0 attribute sets the initial zoom level to 1.0.

<meta name="description" content="Description of your website">
This meta tag provides a brief description of the website, which can be used by search engines or social media platforms when displaying search results or links.

<meta name="keywords" content="keyword1, keyword2, keyword3">
This meta tag specifies a comma-separated list of keywords or phrases that are relevant to the website.

<meta name="author" content="Your Name">
This meta tag specifies the author of the document.

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

This meta tag specifies how search engine crawlers should treat the website. The index attribute tells search engines to index the website, while the following attribute tells search engines to follow the links on the website.

<meta http-equiv="X-UA-Compatible" content="IE=edge">
This meta tag specifies the compatibility mode for Internet Explorer.

References

SQL Concepts

Tejeswararao123 — Wed, 22 Feb 2023 07:07:21 +0000

SQL Concepts

ACID

ACID refers to a set of principles that ensure reliable data transactions
These are the properties of a transaction
Transaction is a logical group of one or more SQL statements

Atomicity:

Either all or none are applied to a database Example: In a banking system for a money transfer two operations have to be done like debit and credit in this scenario two operations or none should be done

Consistency:

Transactions always leave the database in a consistent state

Isolation:

When multiple transactions are being simultaneously executed and in parallel in a database system, then the carrying out and execution of the transaction would occur as if it is the only transaction that exists in the system.
None of the transactions would affect any other transaction’s existence.

Durability:

Once a transaction is committed, its changes are permanent and will survive any subsequent system failures, even power loss or crashes.

CAP Theorem: It states that in a distributed system, it is impossible to simultaneously achieve Consistency, Availability, and partition tolerance

According to the above statement we have to give up something to gain something

Consistency:

Every read operation from the database returns the most recent write or an error. In other words, all nodes in the system see the same data at the same time.

Availability:

Every request to the database receives a response, without guaranteeing that it contains the most recent version of the data. In other words, the system is always up and running, even in the face of network partitions, hardware failures, or other forms of degradation.

Partition tolerance:

The system continues to operate even when network partitions occur, which means that some nodes in the system are unable to communicate with others.

Examples

Trade-off between consistency and availability. Choosing to prioritize consistency may mean sacrificing some level of availability, while prioritizing availability may mean sacrificing some level of consistency.
Another example of a trade-off in database management systems is between performance and data durability. Often, improving performance can come at the cost of reducing data durability. This is because some optimizations, such as buffering or caching data in memory, may increase performance but also increase the risk of data loss in the event of a system failure.

Joins:

JOIN is a clause to combine rows from two or more tables, based on a related column between them.

Types of joins:

Natural join:

NATURAL JOIN combines the tables based on the common columns.

SELECT *
FROM table1
   NATURAL JOIN table2;

Inner Join:

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

SELECT column1, column2, ...
FROM table1
INNER JOIN table2
ON table1.column = table2.column;

CROSS JOIN:

In CROSS JOIN, each row from the first table is combined with all rows in the second table. Cross Join is also called CARTESIAN JOIN

SELECT *
FROM table1
   CROSS JOIN table2;

Full Join:

FULL JOIN or FULL OUTER JOIN is the result of both RIGHT JOIN and LEFT JOIN

SELECT *
FROM table1
   FULL JOIN table2
ON c1 = c2;

Cross Join

Left join:

Returns each row in the left table, and matched rows from the right table are combined. If there is no match, NULL values are assigned to the right half of the rows in the temporary table.

SELECT *
FROM table1
   LEFT JOIN table2 
ON table1.c1 = tabl2.c2;

Right join:

Returns each row in the right table, and matched rows from the left table are combined. If there is no match, NULL values are assigned to the left half of the rows in the temporary table.

Syntax

SELECT *
FROM table1
   RIGHT JOIN table2
ON table1.c1 = table2.c2;

Aggregations, Filters in queries:

These are the function that we can apply after grouping data.

sum():

Calculates the sum of columns for a group of rows or entire data Example

SELECT category, SUM(sales) FROM products GROUP BY category;

Avg():

Calculates the average value of a given column for a group of rows or to entire data Example

SELECT AVG(salary) from EMPLOYEES

count():

Counts the number of rows in a table or the number of rows in a group of rows

SELECT customer, COUNT(order_id) FROM orders GROUP BY customer;

Min():

Returns minimum value of a given column for entire data or grouped data

SELECT department, MIN(salary) FROM employees GROUP BY department;

Max():

Returns the maximum value of a given column for entire data or grouped data

SELECT department, Max(salary) FROM employees GROUP BY department;

Filters:

We use a where clause and having clause to filter rows in a table

Where clause is put before grouping and having clause is written after grouping
Inside these clauses we insert conditions Example:

select batsman,sum(runs) as runs from batsman_runs
where team='rcb'
group by batsman
having runs>2000;

Normalization:

Normalization is a process by which database and table structures are created or modified to address inefficiencies/complexities related to data storage, data modification, and querying database tables ### Normalization can be achieved by following techniques #### 1NF Databases: A 1NF database is an atomic database. In this case, atomic means that each cell contains one value and each row is unique

// This would be a non-atomic table
| Title           | Length     | Type |
|-----------------|------------|------|
| Example A, B, C | 125 inches | B, C |
| Example A, B, C | 125 inches | B, C |
// This would be an atomic table
| ID | Title     | Length     | Type |
|----|-----------|------------|------|
| 1  | Example A | 125 inches | B    |
| 2  | Example A | 125 inches | C    |

Second normal form:

In a table every non-key value should be fully dependent on a primary key Violating the second normal form
2NF is intended to eliminate redundancy and anomalies that can occur when data is stored in a single table.

product_id | supplier_id | product_name | supplier_name | supplier_location
-----------+-------------+--------------+---------------+-----------------
1          | 1           | Widget A     | Supplier X    | Location 1
2          | 1           | Widget B     | Supplier X    | Location 1
3          | 2           | Widget C     | Supplier Y    | Location 2
4          | 2           | Widget D     | Supplier Y    | Location 2

To normalize the above table to 2nd nf modify the above table like below

Table: products
product_id | product_name
-----------+--------------
1          | Widget A
2          | Widget B
3          | Widget C
4          | Widget D

Table: suppliers
supplier_id | supplier_name | supplier_location
------------+---------------+------------------
1           | Supplier X    | Location 1
2           | Supplier Y    | Location 2

Third normal form:

This ensures that every non-key column in a table is not dependent on any other non-key column
Each column in a table must depend only on the primary key and not on any other columns in the table.
3NF is intended to eliminate data redundancy and anomalies that can occur when data is stored in a single table. Violating 3rd normal form:

book_id | author_name | author_email | book_title | book_isbn | book_publisher | publisher_location
--------+-------------+--------------+------------+-----------+----------------+--------------------
1       | John Smith  | john@xyz.com | Book A     | 123456789 | Publisher X    | New York
2       | John Smith  | john@xyz.com | Book B     | 987654321 | Publisher Y    | London
3       | Jane Doe    | jane@xyz.com | Book C     | 111111111 | Publisher Z    | San Francisco

To normalize the above do following

Table: books
book_id | book_title | book_isbn
--------+------------+-----------
1       | Book A     | 123456789
2       | Book B     | 987654321
3       | Book C     | 111111111

Table: authors
author_id | author_name | author_email
----------+-------------+--------------
1         | John Smith  | john@xyz.com
2         | Jane Doe    | jane@xyz.com

Table: publishers
publisher_id | publisher_name | publisher_location
-------------+----------------+--------------------
1            | Publisher X    | New York
2            | Publisher Y    | London
3            | Publisher Z    | San Francisco

Use foreign keys to establish a relationship between tables Indexes ### Boyce-Codd Normal Form (BCNF):
It ensures every non-key column in a table should be functionally dependent only on the primary key and not on any other columns in the table ### Violating the above technique

student_id | student_name | course_id | course_name | instructor_name | instructor_email
-----------+--------------+-----------+-------------+----------------+------------------
1          | John Smith   | 1         | Course A    | Jane Doe       | jane@xyz.com
1          | John Smith   | 2         | Course B    | John Doe       | john@xyz.com
2          | Jane Doe     | 2         | Course B    | John Doe       | john@xyz.com
3          | Bob Johnson  | 3         | Course C    | Jane Doe       | jane@xyz.com

To normalize the above data split the table into three

Table: students
student_id | student_name
-----------+--------------
1          | John Smith
2          | Jane Doe
3          | Bob Johnson

Table: courses
course_id | course_name
----------+------------
1         | Course A
2         | Course B
3         | Course C

Table: instructors
instructor_id | instructor_name | instructor_email
--------------+----------------+------------------
1             | Jane Doe       | jane@xyz.com
2             | John Doe       | john@xyz.com

To establish a relationship we can create another table that will hold all details of the enrollment

Table: enrollment
student_id | course_id | instructor_id
-----------+-----------+--------------
1          | 1         | 1
1          | 2         | 2
2          | 2         | 2
3          | 3         | 1

Transactions:

Nothing but a Set of Queries that are treated as a single unit
Transactions follow the principles of acid Acid properties are explained above
In PostgreSQL, transactions are started with the BEGIN statement and are ended with either the COMMIT statement to apply the changes made within the transaction Example

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE account_id = 123;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 456;
COMMIT;

In the above, if both UPDATE statements execute successfully, the COMMIT statement applies the changes to the database. If an error occurs during the transaction, the ROLLBACK statement will undo the changes made within the transaction, leaving the database in its original state.

Locking mechanism:

Locks are used to restrict users from access to the database, modifying data to ensure that transactions do not interfere with each other
Locking ensures that each transaction can access the data it needs without interfering with other transactions that may be accessing the same data. Type of locking mechanism

1. Shared Locks:

Shared locks allow multiple transactions to read a resource simultaneously without interfering with each other. A shared lock allows other transactions to acquire shared locks but prevents them from acquiring exclusive locks.
Example:

BEGIN;
SELECT * FROM accounts WHERE account_id = 5 FOR SHARE;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 5;
COMMIT;

The SELECT statement acquires a shared lock on the row with account_id = 5 using the FOR SHARE clause
This ensures that other transactions can also acquire shared locks on this row, but prevents them from acquiring exclusive locks until the current transaction has been completed. ### 2.Exclusive Locks: Exclusive locks are used to ensure that only one transaction at a time can modify a resource. An exclusive lock prevents other transactions from acquiring shared or exclusive locks on the same resource. Example:

BEGIN;
SELECT * FROM accounts WHERE account_id = 3 FOR UPDATE;
UPDATE accounts SET balance = balance - 100 WHERE account_id = 3;
COMMIT;

The SELECT statement acquires an exclusive lock on the row with account_id = 3 using the FOR UPDATE clause
This ensures that no other transactions can modify this row until the current transaction has been completed.

3.Row-level Locks:

Row-level locks are used to lock individual rows of data. Row-level locks are useful in situations where multiple transactions need to modify different rows of the same table at the same time.
Example

BEGIN;
SELECT * FROM accounts WHERE account_id = 673 FOR UPDATE;
UPDATE accounts SET balance = balance - 100 WHERE account_id = 673;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 906;
COMMIT;

The first UPDATE statement acquires a row-level lock on the row with account_id = 673
This ensures that no other transactions can modify this row until the current transaction has been completed ### 4. Table-level Locks: Table-level locks are used to lock an entire table. Table-level locks are useful in situations where a transaction needs to modify all rows of a table at the same time Example

BEGIN;
LOCK TABLE accounts IN EXCLUSIVE MODE;
UPDATE accounts SET balance = 0;
COMMIT;

5.Advisory Locks:

Advisory locks are user-defined locks that are not enforced by PostgreSQL itself

These are useful in situations where a user needs to enforce locking based on some application-specific logic. Example:

BEGIN;
SELECT pg_advisory_xact_lock(1234);
UPDATE accounts SET balance = balance - 100 WHERE account_id = 56;
COMMIT;

The SELECT statement acquires an advisory lock with key 1234
This ensures that no other transactions can acquire a lock with the same key until the current transaction has been completed.

Database Isolation Levels:

Database isolation defines the degree to which a transaction must be isolated from the data changes made by another transaction (although in reality there may be a large number of transactions running concurrently). The overall goal is to prevent reads and writes of temporary, aborted, or otherwise incorrect data written by concurrent transactions.

Types of isolation levels

Read uncommitted
Read committed
Repeatable read
Serializable

1. Read uncommitted:

This kind of isolation level is used when we want even the uncommitted values of the rows. All updates and inserts that aren't even committed should be reflected in our transaction. This type of isolation level is commonly used in booking systems where we should be able to see these changes when another transaction tries to update a seat's availability even though that transaction is not committed.

2. Read committed:

It has 2 properties

No dirty reads:
This means values updated through a transaction will only be visible after the completion of a transaction
No Dirty writes:
Whenever a transaction is running on the database and updating particular values those values will not be overwritten by other transactions.
Next transaction will only update values after the completion of the previous transaction #### Implementation of reading committed
Row level locking for write operations
Multiple versions of the doc #### 3. Repeatable read:
Transactions started and not committed will not be visible
Transactions executed later will not be visible

4. Serializable isolation level:

This is the strongest of all isolation levels and guarantees pure isolation. No other transaction can read and write values until that transaction type is executed in the database. This isolation level solves all the problems encountered in all 3 isolation levels discussed previously, but since this only allows one query to be run on the database, it limits the scalability of the system.

Triggers:

Triggers are SQL codes that are automatically executed in response to certain events on a particular table

These are used to maintain the integrity of data #### Syntax

create trigger trigger_name
(before|after)[Insert | Update |Delete] 
on [Table name]
[For each row | For each column]
[Trigger body]

Nested triggers in SQL are the actions that are automatically executed when a certain database operation is performed #### operations in trigger
Drop: To remove a trigger from the database

Drop trigger trigger_name

Displaying triggers in a database

SHOW TRIGGERS 
IN database_name;

Insert Before inserting triggers:
Used to update or validate record values before they are saved to the database

CREATE TRIGGER calculate
before insert 
ON STUDENT 
FOR EACH ROW
set new.marks=new.marks+100;

After inserting the trigger:

Used to access field values that are set by the system and to effect changes in other records Example:

CREATE TRIGGER total_mark
after insert 
ON STUDENT 
FOR EACH ROW
insert into final_mark values(new.marks);

References

SOLID Principles in OOP

Tejeswararao123 — Mon, 20 Feb 2023 07:06:05 +0000

Solid principles in OOP

The SOLID principles are helpful to build scalable, flexible, readable softwares.
These principles are intriduced by Bob Martin

SOLID stands for:

Single Responsibility Principle (SRP)
Open/Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

1.Single Responsibility Principle (SRP)

*This principle states that each class should have only one responsibility or reason to modify class.

Example:

class FileHandler:
    def read_file(self, file_path):
        with open(file_path, 'r') as f:
            data = f.read()
        return data

    def write_file(self, file_path, data):
        with open(file_path, 'w') as f:
            f.write(data)

In this example, FileHandler class has a single responsibility, which is to handle file operations such as reading and writing. If we need to add or modify file operations, we only need to change this class.
Finally this SRP is a valuable principle that helps us write code that is easier to understand, modify, and extend. By focusing each class on a single responsibility, we can make our code more maintainable and reduce the likelihood of bugs and other issues.

2. The Open-Closed Principle (OCP)

It is a design principle in object-oriented programming that states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that you should be able to add new functionality to a program without changing the existing code.

we can implement the above using inheritance and polymorphism. Here is an example:

Suppose we have a program that calculates the area of different shapes (e.g. rectangle, circle, triangle). We can create a base class called Shape that defines the common properties and methods of all shapes:

class Shape:
    def area(self):
        pass

Then we can create different classes that inherit from the Shape class and implement their own area method:

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

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


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

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


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

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

Now, if we want to add a new shape (e.g. a square), we don't have to modify the existing code. We can simply create a new class that inherits from the Shape class and implements its own area method:

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2
This way, we are able to extend the program without modifying the existing code, which is the essence of the Open-Closed Principle.

3.Liskov principle

The Liskov Substitution Principle is a concept in object-oriented programming that states that if a program is using a base class, it should be able to use any of its derived classes without knowing it. In simpler terms, it means that the derived classes should be able to substitute the base class without affecting the correctness of the program.

we can demonstrate this principle through an example. Let's say we have a Rectangle class that has a width and a height property, and a calculate_area() method that calculates the area of the rectangle:

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

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

Now, let's say we want to create a Square class that is a subclass of Rectangle. A square is just a special case of a rectangle where the width and height are the same, so we can create a Square class like this:

class Square(Rectangle):
    def __init__(self, side_length):
        super().__init__(side_length, side_length)

This implementation satisfies the Liskov Substitution Principle because we can substitute a Square object for a Rectangle object without affecting the correctness of the program. For example, if we have a function that takes a Rectangle object and calls its calculate_area() method, we can pass a Square object to it:

def print_area(rectangle):
    print(rectangle.calculate_area())

rectangle = Rectangle(3, 4)
square = Square(5)

print_area(rectangle)  # output: 12
print_area(square)  # output: 25

The print_area() function doesn't know or care whether it's dealing with a Rectangle or a Square object. It just calls the calculate_area() method, and the correct area is calculated. This demonstrates the Liskov Substitution Principle in action.

4.The Interface Segregation Principle (ISP):

It is a concept in object-oriented programming that states that a class should not be forced to implement interfaces that it does not use. In other words, a class should only be required to implement methods that are relevant to its behavior and should not be burdened with unnecessary methods.

we can demonstrate this principle with an example. Let's say we have an Animal interface that has several methods, including eat(), sleep(), and play():

class Animal:
    def eat(self):
        pass

    def sleep(self):
        pass

    def play(self):
        pass

Now, let's say we want to create two classes that implement the Animal interface: a Dog class and a Cat class. Dogs and cats are both animals, but they have different behaviors. For example, dogs might have a bark() method and cats might have a purr() method. We don't want to force every animal to implement methods that are specific to one type of animal, so we can create separate interfaces for dogs and cats:

class Animal:
    def eat(self):
        pass

    def sleep(self):
        pass

class Dog(Animal):
    def bark(self):
        pass

class Cat(Animal):
    def purr(self):
        pass

In this implementation, the Animal interface only contains methods that are common to all animals, such as eat() and sleep(). The Dog and Cat classes extend the Animal class but also have their own specific methods, such as bark() for dogs and purr() for cats.

This implementation satisfies the Interface Segregation Principle because each class is only required to implement the methods that are relevant to its behavior. The Dog class doesn't need to implement the purr() method, and the Cat class doesn't need to implement the bark() method. By separating the interface into smaller, more specific interfaces, we can keep our code more modular and avoid unnecessary dependencies.

5.The Dependency Inversion Principle (DIP):

This principle states that high-level modules should not depend on low-level modules, but should instead depend on abstractions. In simpler terms, it means that instead of depending on specific implementations, classes should depend on abstract interfaces or classes.

Below FileReader class reads data from a file:

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

Now, let's say we have a DataProcessor class that processes data from a file:

class DataProcessor:
    def __init__(self, reader):
        self.reader = reader

    def process_data(self, filename):
        data = self.reader.read_file(filename)
        # process the data...

In this implementation, the DataProcessor class depends on the FileReader class to read data from a file. This violates the Dependency Inversion Principle because the high-level DataProcessor class is depending on the low-level FileReader class.

To fix this, we can create an abstract interface or class for reading files, and have the FileReader class implement that interface or inherit from that class. Then, we can modify the DataProcessor class to depend on the abstract interface or class instead of the FileReader class directly:

class FileReaderInterface:
    def read_file(self, filename):
        pass

class FileReader(FileReaderInterface):
    def read_file(self, filename):
        with open(filename, 'r') as file:
            return file.read()

class DataProcessor:
    def __init__(self, reader):
        self.reader = reader

    def process_data(self, filename):
        data = self.reader.read_file(filename)
        # process the data...

Now, the DataProcessor class depends on the FileReaderInterface abstract interface instead of the FileReader class directly. This allows us to easily swap out the FileReader class with a different file reader implementation that also implements the FileReaderInterface. We can also create other file readers that implement the FileReaderInterface interface or inherit from the FileReaderInterface class, and use them with the DataProcessor class without modifying the DataProcessor class.

This implementation satisfies the Dependency Inversion Principle because the high-level DataProcessor class depends on an abstraction instead of a specific implementation. This makes the code more modular and flexible, and allows us to easily switch out implementations without affecting other parts of the code.

References

Strings, Lists and OOPS in Python

Tejeswararao123 — Thu, 16 Feb 2023 07:03:20 +0000

String Methods

isupper()

Returns True if all the characters in a string are in uppercase ### Example

a = "Hello"
b="HI"
print(a.isupper()) # False
print(b.isupper()) # True

islower()

Returns True if all the characters in a string are in lowercase ### Example

a = "hello"
b="HI"
print(a.islower()) # True
print(b.islower()) # False

isalnum()

Returns True if the string contains only alphabetical letters and digits.

a = "hello5 4 3"
b="HI567hello"
print(a.isalnum()) # False 
print(b.isalnum()) # True

count():

a="hi hello how are you hello"
print(a.count("hello")) # 2
print(a.count("h")) # 4

isdigit():

Returns True if all characters are digits

capitalize()

Change the case first character in a string to upper case

name = 'python'
# syntax
name_cap = name.capitalize()
print(name_cap) # Python

upper():

Change the cases of all characters of a string to uppercase

a = "hi hello!"
a = a.upper()
print(a) # HI HELLO!

lower():

Change the cases of all characters of a string to lowercase

a = "HI HELLO!"
a = a.lower()
print(a) # hi hello!

swapcase()

swap the cases of all characters in a string. string = 'Who Are You?' after_swapcase = string.swapcase() print(after_swapcase) # wHO aRE yOU?

greeting = "Happy birthday"
index = greeting.index('ppy')
print(index)  # 2

replace():

Replace all the occurrences with another string

a = 'i am from Andhrapradesh'
b= a.replace('Andhrapradesh', 'Delhi')
print(b) # 'i am from Delhi'

String slicing:

returns a substring from the original string

Example

a = "Hello Raj"
b = a[0:5]
print(b) # Hello

startswith()

Returns true if the string starts with a given string

a = "hi hello how are you"
print(a.startswith("hi")) # True

endswith()

This method returns True if the string ends with the given string

a = "hi hello how are you"
print(a.endswith("you")) # True

strip():

This method removes specified characters from the string by default it removes spaces

a = ";' hello ';;'"
print(a.strip("'; ")) # hello

split():

splits the given strings into a list of words a="hi hello" print(a.split()) # ['hi', 'hello']

List methods

join()

This method joins the list of elements with a separator

a = ["hi","hello"]
b=" ".join(a)
print(b) # hi hello

slicing

This method returns the sliced list

a=[2,3,4,5,6,7,8,9]
b=a[1:4]
print(b) # [3,4,5]

append():

Add passed argument to the end of the list

a=[12,42,23,34,55]
a.append(19)
print(a)  # [12,42,23,34,55,19]

del

delete element specified index

a=[2,3,4,5,6]
del a[3]
print(a) # [2,3,4,6]

clear()

delete all elements

a=[2,3,4,5,6]
a.clear()
print(a) # []

count():

This method returns the number of occurrences of the given element in the list

a=[2,3,4,5,6,3,3,3]
y=a.count(3)
print(y) # 4

extend():

Add items iterable to the end of the list

a=[2,3,4,5,6]
a.extend([7,9])
print(a) # [2,3,4,5,6,7,9]

index()

This method returns the index of the first occurrence given value in the list

a=[3,4,5,6,7]
index=a.index(5)
print(index) # 2

insert()

This method insert an element at the given position in the list.

a = [3,5,6,7]
a.insert(1,4)
print(a) # [3, 4, 5, 6, 7]

pop() By default removes the last element else at a specified index

a = [3,5,6,7]
a.pop(0)
print(a) # [5,6,7]

reverse()

reverse the order of elements

a = [3,5,6,7]
a.reverse()
print(a) # [7, 6, 5, 3]

sort()

sorts the list into ascending or descending order

a =[2,3,6,4,5]
a.sort()
print(a) # [2, 3, 4, 5, 6]
# to sort the list in descending order
a =[2,3,6,4,5]
a.sort(reverse=True)
print(a) # [6, 5, 4, 3, 2]

OOP

OOP is a way of approach to building good software that make users and developers happy.
We achieve the above using classes and functions
Using classes we create instances
Class is used to bundling of properties and methods(functions)
Class functions is a synonym for methods
Class – a blueprint for an instance with exact behavior.
Object – one of the instances of the class, performs functionality defined in the
class.
Type – indicates the class the instance belongs to
Attribute – Any object value: object.attribute
Method – a “callable attribute” defined in the class
Class attributes are the attributes that are not specific to instance, common for all

init method in class

This method is used to create an instance with some specific set of properties
It is a constructor of the class.

Creating a class and its functions

The following functions are achieved in the following class

Accessing modifying the instance attribute and class attributes

class MyClass():
    hi=10
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def print_my_name(self):
        print(f"Your name is {self.name}")

    def print_my_age(self):
        print(f"Your age is {self.age}")

    def change_my_age(self,age):
        self.age=age

obj = MyClass("Tejeswar",23)
obj.print_my_name() # Your name is Tejeswar
obj.print_my_age()  # Your age is 23
obj.change_my_age(25)
obj.print_my_age() # Your age is 25
print(obj.hi)
obj.hi=20
print(obj.hi) # 20
print(MyClass.hi) # 10
MyClass.hi=30 
print(MyClass.hi) # 30
print(obj.hi) # 20

Features

Encapsulation means bundling related properties and methods

Inheritance

Here we can inherit the methods from the parent class by extending our class to the parent class ### Polymorphism
We can have the same names for different functions to avoid overriding we have to call with the prefix super()

There are three types of methods in class

Instance Methods:

Instance methods can access all attributes of the instance and take self as a parameter.
These methods are accessed by instances

class Cart:
   def __init__(self):
       self.items = {}
   def add_item(self, item_name,quantity):
       self.items[item_name] = quantity
   def display_items(self):
       print(self.items) # {'book': 3}

a = Cart()
a.add_item("book", 3)
a.display_items()

Class Methods:

Methods that need access to class attributes but not instance attributes are marked as Class Methods.
For class methods, we send cls as a parameter indicating we are passing the class.
These methods are accessed through classes

class Cart:
   flat_discount = 0
   @classmethod
   def update_flat_discount(cls, new_flat_discount):
       cls.flat_discount = new_flat_discount

Cart.update_flat_discount(25)
print(Cart.flat_discount) # 25

Static Method:

Usually, static methods are used to create utility functions that make more sense to be part of the class.
@staticmethod decorator marks the method below it as a static method.
These methods are accessed through classes

class Cart:
   @staticmethod
   def greet():
       print("Good morning") # Good morning

Cart.greet()

Regular Expressions

Tejeswararao123 — Thu, 02 Feb 2023 06:07:01 +0000

Regular Expressions

Regular expression is a sequence of characters that defines a search pattern.
It is a impressive tool for searching a pattern.

Example

string_a = re.search(r'portal', 'portal for folks')
print(string_a)
print(string_a.group())
print('Start from the Index:', string_a.start())
print('Ends at the Index:', string_a.end())

output:

<re.Match object; span=(0, 6), match='portal'>
portal
Start from the Index: 0
Ends at the Index: 6

Meta Characters

The below table shows the list of MetaCharacters are used in regex

Applications

Data Mining:

Data mining is the process of sorting large amounts of data to identify patterns and relationships that can help solve business problems through data analysis.

Data Validation:

Data validation is the process of checking and validating data that is collected before it is used.

Basic regular expressions.

Character Classes

Character classes allow us to match a single character set against a possible character set. You can also place a character class inside the square brackets.

Ranges

The range provides the versatility to match a text in the range. The hyphen character within the character class represents a range.

Shortcuts in RegEx.

\w – matches a word character
\d – matches digit character
\s – matches white space character (space, tab, newline, etc.)
\b – matches a zero-length character

Negation

Negation inverts character classes. Finds a match excluding the reversed character or range of reversed characters specified in the character class.

Ends of String

The caret character matches the beginning of the string and the $ character matches at the end of the string.

Any Character

The period character represents any single character except the character classes enclosed in parentheses.

DEV Community: Tejeswararao123

Django

Settings File:

Secret Key:

Default Django Apps:

django.contrib.admin:

django.contrib.auth:

django.contrib.contenttypes:

django.contrib.sessions:

django.contrib.messages:

django.contrib.staticfiles:

django.contrib.humanize:

django.contrib.sites:

django.contrib.redirects:

django.contrib.sitemaps:

django.contrib.syndication:

Middleware:

Different Kinds of Middleware:

Django Security:

CSRF:

XSS:

Clickjacking:

Other Middleware:

WSGI:

Models File:

Ondelete Cascade:

Fields and Validators:

Python Module vs Python Class:

Django ORM:

Using ORM Queries in Django Shell:

Turning ORM to SQL in Django Shell:

Aggregations:

Annotations:

Migration Files:

SQL Transactions:

Atomic Transactions:

Scope, Hoisting and Closures in Javascript

Scope

Hoisting

Closures

HTML and CSS concepts

Box Model:

Border:

Box-sizing in CSS

Inline versus Block Elements:

Block elements:

inline elements

Positioning: Relative/Absolute

position relative

position absolute:

Common CSS structural classes:

Child Selector

Sibling Selector

The adjacent sibling selector (represented by the + symbol)

The general sibling selector (represented by the ~ symbol):

pseudo-classes

:active

:focus

:first-child and :last-child

:nth-child()

Common CSS styling classes

.btn

.card

.form-control

text-center

CSS Specificity

CSS Responsive Queries

Flexbox/Grid

Flexbox

display:

flex-direction:

justify-content:

align-items:

flex-wrap:

align-content:

flex:

Grid

display: grid;:

grid-template-columns and grid-template-rows:

grid-template-areas: