DEV Community: viyashdoss

Django

viyashdoss — Tue, 04 Apr 2023 10:55:57 +0000

Settings file:

All project-specific parameters, including database connection, static files, middleware, installed apps, and more, are stored in the settings file in Django.

What is the secret key?

To secure Django applications, cryptographic hashing and signing are done using secret keys, which are random strings of characters.
It is employed for activities like creating secure cookies and preventing CSRF attacks.
To stop hackers from gaining access to private data, the secret key must be maintained safe, With the Django.core.management.utils.get the random secret key() function, you can create a reliable secret key.

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

Static files, sessions, messages, and content types are the default Django apps that are listed in the settings file. Django offers more third-party apps too.

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

Middleware is a tool that can be used to add extra features to the way your web application handles requests and responses. Different types of middleware can help address various security issues, like preventing CSRF (Cross-Site Request Forgery) attacks, protecting against XSS (Cross-Site Scripting) attacks, and preventing clickjacking.
The different kinds of middleware available include authentication middleware, caching middleware, logging middleware, compression middleware, and error handling middleware. Each type of middleware serves a different purpose, such as verifying the identity of users trying to access protected resources, improving the performance of web applications by storing frequently accessed data, capturing and storing logs of various activities and events, compressing content before sending it to the client and catching and handling errors that may occur during the execution of a web application.

CSRF

CSRF (Cross-Site Request Forgery): A CSRF attack is when an attacker tricks a user into acting on a website without their knowledge or consent. To prevent this, Django includes built-in protection that requires a secret token to be included in POST requests, which ensures that the request is coming from a legitimate source.

XSS

XSS (Cross-Site Scripting): XSS is a type of attack where an attacker injects malicious code into a web page, which can then be executed by unsuspecting users. To prevent this, Django includes built-in protection that automatically escapes any user-provided data in templates and form fields.

Clickjacking

Clickjacking is a type of attack where an attacker tricks a user into clicking on a button or link that is invisible or hidden on a web page. To prevent this, Django includes built-in protection that adds a special header to responses that prevents them from being embedded within other sites.

Any other middleware that is there?

Session Middleware: This middleware handles the creation and management of user sessions, which can be used to store user-specific data across multiple requests.
Content Security Policy Middleware: This middleware helps protect against XSS attacks by specifying which sources of content are allowed to be loaded on a page.
CorsMiddleware: This middleware allows you to specify which domains are allowed to access your site's resources, which can help prevent unauthorized access from other sites.

WSGI

It will serve as a start point for a webserver.
Django is designed to work with the WSGI (Web Server Gateway Interface) standard, which allows it to be deployed on a wide variety of web servers and platforms. When you create a new Django project using the start project command, it automatically generates a basic WSGI configuration file for you, which you can customize as needed to fit your specific deployment requirements. This makes it easy to deploy a Django application to a variety of production environments, including popular web servers like Apache and Nginx.

Models file:

The model's file in Django defines the database schema for a project using Python classes.

What is on deleting Cascade?

On delete cascade is a database constraint that automatically deletes related records in child tables when a record is deleted in the parent table.

A broad understanding of Fields and Validators available to you?

In Django, models are used to define the structure and behaviour of data that will be stored in a database. Fields are used to define the type of data that will be stored in each field of a model. For example, a CharField is used to store a string of text, while an IntegerField is used to store a numerical value.
Validators are functions that can be used to check the validity of data before it is saved to the database. For example, we might use a validator to check that a user-entered email address is in a valid format. Validators can be attached to fields in a model to ensure that the data stored in those fields is valid according to your requirements.

Understanding the difference between Python module and Python class?

A Python module is a file containing Python code, while a Python class is a blueprint for creating objects.

Django ORM:

Using ORM queries in Django Shell

The Django ORM is a high-level Python API for interacting with relational databases.
The ORM queries can be tested in the Django shell, which provides an interactive Python environment to execute code. To open the shell use the below command

  python manage.py shell

Turning ORM to SQL in Django Shell

ORM queries can be turned into SQL queries in the Django shell by using the query method.

  queryset = model.objects.all()
  print(queryset.query)

What are Aggregations?

Aggregations are operations performed on data to return a single result, such as count, sum, avg, max, and min.

What are Annotations?

Annotations allow adding extra data to a query result, such as adding a count of related records to the main record.

What is a migration file? Why is it needed?

Migration files are generated by Django to manage database schema changes.

What are SQL transactions? (non-ORM concept)

SQL transactions are a way to group multiple SQL queries into a single atomic operation, ensuring data consistency.

What are atomic transactions?

Atomic transaction is the smallest set of operations to perform the required steps. Either all of those required operations happen(successfully) or the atomic transaction fails.

References

https://docs.djangoproject.com/en/4.0

CSS - Concepts

viyashdoss — Thu, 02 Mar 2023 07:14:03 +0000

Box Model

The CSS box type is like a container that has the following properties:

Content

This section includes the primary content, such as text, images, and other media. The height and width characteristics can be changed.

Padding

The padding area is the space between the content region and the border box. It can be applied to all sides or particular sides such as the top, right, bottom, and left.

Border

The border area surrounds the padding and content and can be applied to all sides or particular sides such as the top, right, bottom, and left.

Margin

The margin region is the space between the border and the outside edge of the box.


<style>

div {

  width: 300px;

  height: 200px;

border: 2 pixels of solid black;

  padding: 10px;

  margin: 20px;

}

</style>

<html>

<body>

<div>

some content

</div>

</body>

</html>

In the preceding example, the innermost layer of the div element that includes the real content has a width of 300px, and the padding property surrounds the content layer and provides 10px space between the content and the border.

The border property surrounds the padding layer and provides a visible border of 2 px, and the margin property is the outermost layer that surrounds the complete element.

Inline VS Block

Block - HTML Block Level elements commence on a new line and occupy the entire width of their parent element. They have the ability to utilize width, height, and text-align properties as they fill the entire width of their container.

Inline - HTML inline elements consistently begin on the same line and their width is determined by their content. Most inline elements are presentational.

Block	Inline
A block level element can have both inline and block elements as children or descendants	inline level elements can have only inline elements as children or descendant.
CSS property: display:block	CSS property: display:inline

Postioning Absolute/Relative

Aboslute - When an element is assigned a position value of "absolute", its position is determined in relation to the closest ancestor element that has a specified position (as opposed to being positioned relative to the viewport, which is the case for "fixed" elements).

In the absence of any such ancestor, an absolutely positioned element is placed in relation to the document body and will scroll along with the page.

It's important to note that elements with absolute positioning are taken out of the normal flow of the page and may overlap with other elements.

Relative - When an element is assigned a position value of "relative", it will be positioned based on its default position. If the top, right, bottom, or left properties are specified, the element's position will be adjusted accordingly, but the surrounding content will not be affected to fill the space created by the element's displacement.

div.relative {
  position: relative;
  width: 400px;
  height: 200px;
  border: 3px solid #73AD21;
}

div.absolute {
  position: absolute;
  top: 80px;
  right: 0;
  width: 200px;
  height: 100px;
  border: 3px solid #73AD21;
}

CSS Structural Classes

They allow you to target specific elements like the first child, last child, or alternate elements based on their position in the hierarchy. Here are some common examples:

:first-child - targets the element that appears first among its siblings.
:nth-child(n) - targets elements at a certain position, based on an expression.
:last-child- targets the element that appears last among its siblings.
:nth-last-child(n) - like :nth-child, but starts counting from the end.
:only-child - targets elements that are the only child of their parent element.
:first-of-type - targets the first element of a specific type of sibling.
:nth-of-type(n) - targets elements of a specific type at a position determined by an expression.
:last-of-type - targets the last element of a specific type of sibling. :nth-last-of-type(n) - like :nth-of-type, but starts counting from the end.

CSS Specifity

It is a method used to determine which CSS rule applies to an HTML element when there are multiple rules targeting the same element. Specificity is calculated based on the type of selector used in the rule, and the number of instances of each selector in the rule.

Four types of selectors in CSS:

type selectors,
class selectors,
ID selectors,
attribute selectors.

The selectors are ranked in order of increasing specificity, with type selectors having the lowest specificity and ID selectors having the highest.
!important keyword can be applied to override specificity and force a rule to apply to an element, it is better to avoid this keyword.

CSS Responsive Queries

It is used in CSS to apply styles to different devices or screen sizes. Media queries allow web developers to specify different CSS styles for different devices, resolutions, and orientations.

The media query includes a media type, such as screen, print, or speech, and one or more expressions that define the conditions under which the styles should be applied. For example, you can use a media query to apply styles only to devices with a maximum width of 768 pixels, or to print styles that are optimized for printing on paper.

@media (max-width: 768px) {
  body {
    background-color: blue;
  }
}

Flex and Grid

CSS Grid and Flexbox are two different properties that web developers can use to create complex and responsive web layouts.

CSS Grid is a layout module that works by creating a grid of rows and columns on a webpage. Once you've created your grid, you can place content within it by specifying which grid lines and areas should be used. This makes CSS Grid really useful for creating layouts that need to be highly controlled and complex, like those you might see in a magazine or on a dashboard.

Flexbox, on the other hand, is a layout module that works by creating containers that can be used to organize items on a webpage. we can use Flexbox to tell these containers how the items within them should be organized, like by specifying whether they should be laid out in a row or a column. This makes Flexbox really useful for creating layouts that need to be more flexible and responsive to different screen sizes, like a navigation menu or a gallery of images.

Meta Tags

The meta tag provides information about a web page, such as its description, keywords, author, and character encoding.
This information can be used by web browsers to display information about the page and can aid in search engine optimization.

The name attribute specifies the type of metadata provided, while the content attribute contains the actual metadata content.

The charset attribute specifies the web page's character encoding.

Reference

SQL Concepts

viyashdoss — Wed, 22 Feb 2023 06:45:02 +0000

ACID

ACID is a term used in transaction processing to refer to a set of four critical properties that transactions should exhibit. These four properties are atomicity, consistency, isolation, and durability.

Atomicity ensures that all changes made by a transaction are treated as a single operation, meaning that either all of the changes are made or none of them are.
Consistency guarantees that the data is in a consistent state before and after the transaction is executed.
Isolation - Concurrent transactions will not interfere with one another, and each transaction will be executed independently of the others. Even though the requests are occurring simultaneously, But they're being processed one by one.
durability ensures that once a transaction is successfully completed, the changes made to the data persist and are not lost, even in the event of a system failure.

Overall, these properties help ensure that transactions are reliable, robust, and maintain data integrity, making them critical for the proper functioning of computer systems that process transactions.

CAP Theorem

A network with numerous nodes (physical or virtual machines) simultaneously storing data is known as a distributed system. Understanding the CAP theorem is essential when creating a cloud application because all cloud apps are distributed systems.
To ensure that the system continues to provide a reliable service despite these partitions, partition tolerance becomes a necessity.
This indicates that in a distributed system, achieving high consistency may come at the expense of reduced availability, whereas prioritising high availability may result in poorer consistency.
The CAP theorem is often referred to as Brewer's theorem.

Joins

Joins in SQL Server allow you to retrieve data from various tables based on logical links.
Joins specify how data from one table should be used to select rows from another table.
Joins can be done logically using the following SQL syntax:

INNER JOIN - By using the INNER JOIN keyword, only the rows from both tables with matching columns will be selected with condition which we're giving it.
LEFT JOIN - The LEFT JOIN command retrieves all rows from the left table as well as the matching rows from the right table.If there is no match, the result from the right side is NULL.
RIGHT JOIN - The RIGHT JOIN also is same as the left join, the only difference is retrieves from right, we can acheive right join by left also by swapping the table name.
FULL JOIN - When there is a match in either the left or right tables, the FULL OUTER JOIN statement returns all rows.

Aggregations, Filters in queries

Aggregations - A single output value is computed by SQL aggregate functions using various column input values. These operations are frequently combined with the SELECT statement's GROUP BY and HAVING clauses. The SQL aggregate functions that are used most frequently are
- Count() - To find the count of data.
- Sum() - To find sum of the column.
- Average() - To find avg value.
- Min() - To find min value.
- Max () - To find max value.
Filters - A subset of data items within SQL and internal database types are defined by text strings known as SQL filters.

These filters often take the form of a SQL WHERE clause, which includes a set of comparisons that need to be met in order for a specific data item to be returned.

These comparisons typically involve field names and the values that correspond to those names.

Normalization

Removing redundant data from your tables will increase storage effectiveness, data integrity, and scalability. This procedure is known as database normalisation.There are ways to measure a database's effectiveness in the relational paradigm.Normal forms (or NF) are the name given to these classes, and there are algorithms for converting a given database between them.

In order to "normalise" an existing table, it is typically split into many ones that need to be "re-joined" or "connected" each time a query is run.

Types of Normal Forms:

1NF - According to the first normal form (1NF), a table attribute can only carry one value and cannot hold more than one value. As a result, 1NF forbids the use of composite attributes, multi-valued attributes, or any combination of the two.
2NF - A table must comply to the first normal form (1NF) before it may satisfy the second normal form (2NF) (1NF). Furthermore, the main key must be completely functionally dependent on all non-key properties in the database.
3NF - A relation is in 3NF if it is in 2NF and does not contain any transitive partial dependencies.To lessen data duplication, 3NF is used.It is also employed to ensure data integrity.The relation must be in third normal form if there is no transitive dependency for non-prime attributes.
BCNF - Boyce Codd's normal form is an improved definition of 3NF.
4NF - Boyce Codd normal form and the absence of any multi-valued dependencies must both be met for a relation to be categorised as being in fourth normal form (4NF).When there are multiple values of B connected to a single value of A for a given dependency A B, this is referred to as a multi-valued dependency.
5NF - When all of the tables are divided up into as many different tables as is possible to prevent redundancy, 5NF is satisfied.Project-join normal form, or 5NF, is another name for this format.

Index

In order to speed up data retrieval, the database search engine uses indexes as lookup tables.
They operate similarly to an index at the end of a journal by making references to information in a table.
The purpose of a database index is to speed up database access even though users cannot see it.

In order to find all the pages in a book that are related to a particular topic, for instance, you would first look in the index, which lists the topics in alphabetical order, before moving on to one or more specific page numbers.

In addition to speeding up data retrieval, indexes also stop duplicate entries from being made in the column or group of columns on which they are created.

for example :

CREATE INDEX index_name ON table_name(column_name); - To create index
DROP INDEX college_index; - To drop index

Transactions

A transaction in SQL is a group of one or more SQL statements that communicate with a database.
To undo the changes performed, it can be rolled back as a single logical unit or committed to a database as a single unified logical unit.
When numerous concurrent operations or users are interacting with the database at once, transactions are essential to SQL's ability to ensure database integrity.
By ensuring that related operations are carried out simultaneously and committed as a single logical unit, they contribute to integrity preservation.

Locking Mechanism

To maintain data consistency in SQL, it is essential to utilize SQL Locks. A lock is created at the beginning of a transaction and is released when the transaction is completed in SQL . There are several types of locks available for use.

One type is the Shared (S) Lock, which is used to read an object without making any changes to it.
Another type is the Exclusive (X) Lock, which blocks other operations like inserting, updating, or deleting data on the locked objects.
The Update (U) Lock is another type of lock that is similar to the Exclusive lock. However, it allows for a "read phase" and a "write phase," and some transactions may be restricted during the read phase.
Lastly, the Intent Lock is used to indicate that an object will be locked shortly by another type of lock.

Database Isolation

Isolation controls how transaction integrity is visible to other users and systems in database systems.
A lower level of isolation makes it easier for several users to access the same data concurrently, but it also makes it more likely that users will experience concurrency impacts like losting the changes.

Triggers

Storage-based programmes known as triggers are launched or automatically run when specific events take place.
In reality, triggers are written to run in response to any of the following situations:

A DML statement is used to manipulate databases (DELETE, INSERT, or UPDATE)
An explanation of the database (DDL) (CREATE, ALTER, or DROP).
operating a database (SERVERERROR, LOGON, LOGOFF, STARTUP, or SHUTDOWN).

Tables, views, schemas, and databases that are connected to an event can all have triggers defined on them.

Reference

Solid Principles - Python

viyashdoss — Mon, 20 Feb 2023 07:02:14 +0000

Solid principles are a set of instructions on how to write code for production-ready software. Every software developer has to know these crucial principles to develop any application, Solid stands for

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

Single Responsibility Principle :

A class should have a single responsibility for handling processes, and if there is anything to change, it should not affect the other classes. The main objective of the single responsibility principle is to design a software component with attributes and methods that are related to each other, and it should not handle more stuff; the smaller the class, the better.

It can have any number of methods if all are coupled with each other; otherwise, we need to separate those methods into separate classes.

Class Game:

    def initializer_method(self):
        pass

    def draw_method(self):
        pass

    def running_method(self):
        pass

    def endCond_method(self):
        pass

In the above example, we have to decouple all of the methods in the game class since some of them (draw, running) are not related to each other.

Open-Closed Principle :

Open/closed principle is all about open for extension but closed for modification.
It is co-related to the single responsibility principle. The code which we are writing should be capable of adding extra features without breaking the existing code.

def read_file(file):
    return open(file, "r").read()

def get_text_from_url(URL):
    return text

def count_word_occurrences(word, content):
    counter = 0
    for e in content.split():
        if word.lower() == e.lower():
            counter += 1
    return counter

def csv_reader(file):
    return text

In the above example, we are counting the number of words in a file by reading through the file as well as from the web. What happens when we want to read a file from another resource, like a CSV file? We can create a function to read CSV data and return the text as above to the count_word function.

Liskov’s Substitution Principle :

It states that objects of a parent class should be replaceable with objects of its subclasses without breaking the existing code/application.

For example, Consider the below one mixer class is inheriting the kitchen parent class, what if we want to add another class Owen which has to inherit from the Kitchen class, then we can call those methods alone will work but we have to use all the methods from the parent class.

class kitchen():

    def on():
        pass

    def off():
        pass

    def set_level():
        pass

class mixer(Kitchen):
    def on():
        pass

    def off():
        pass

    def set_level():
        pass

class mixer(Kitchen):

    def on():
        pass

    def off():
        pass

So to overcome this we can create another class to set the level of the mixer and we can inherit that class and use its methods of it.

class kitchen():
    def on():
        pass
    def off():
        pass

class mixer_level(kitchen):
    def set_level():
        pass

class mixer(mixer_level):
    def on():
        pass
    def off():
        pass
    def set_level():
        pass

class mixer(Kitchen):
    def on():
        pass
    def off():
        pass

Interface Segregation Principle :

A class or function should not have all the functionalities in a single method; instead, they should be separated.

In the example below, we force the function to read data from both the URL and the file; however, what if the class that invokes this function does not need to fetch data from the URL? In that case, we must create a separate class for that functionality. If the class needs to read data from both, they can initialise objects for both classes and invoke the main function.
```
def get_text_from_url(URL):
    pass

def count_word_occurrences(word, content):
    file_data=open(file, "r").read()
    url_data = get_text_from_url(URL)
    counter = 0
    for e in content.split():
        if word.lower() == e.lower():
            counter += 1
    return counter
```

Dependency Inversion :

This principle states that higher-level modules should not depend on lower-level modules. Instead, both should depend on abstractions.
In the below example, Food, production is like the base class and if we want to add another food we can create another class and inherit from the food class without breaking it. In this way low and high level classes is depending on the abstract class FOOD.

```
class FOOD:
    def bake(self): 
        pass
    def eat(self): 
        pass

class Bread(FOOD):
    def bake(self):
        print("Bread was baked")
    def eat(self):
        print("Bread was eaten")


class Production:
    def __init__(self, food):
        self.food = food 

    def produce(self):
        self. food.bake() 

    def consume(self):
        self. food.eat()  

ProduceBread = Production(Bread())
```

References

Python Strings/Lists/OOPS

viyashdoss — Thu, 16 Feb 2023 06:39:51 +0000

Every programming language has its methods for its data structures. Some of the data structures in Python include list, string, dictionary, and set.

List methods

append() - Append an element to the end of the list.
```
 l=[]
 l.append(5)
 print(l)
 # l=[5]
```
clear() - Clears the list.
```
 l=[1,2]
 l.clear()
 print(l)
 # l=[]
```

copy() - Makes a copy of the list.

 l=[1,2,3]
 x=l.copy()
 print(x)
 # [1,2,3]

count() - Count the data that has been passed as an argument in the list.
```
 l=[1,2,3]
 x=l.count(1)
 print(x)
 # 1
```

extend() - This function extends the data of another list.

 l=[1,2,3]
 l1=[4,5,6]
 l=l.extend(l1)
 print(l)
 # [1,2,3,4,5,6]

index() - Returns the index of the passed element.
```
 l = [1,2,3]
 l=l.index(1)
 print(l)
 # 0
```

insert() - Takes two arguments, one being the position and another being the element. It will insert at the given position.
```
 l=[1,2,3]
 l.insert(0,0)
 print(l)
 #[0,1,2,3]
```

pop() - Removes the list's last element.
```
 l=[1,2,3]
 l.pop()
 print(l)
 # [1,2]
```

remove() - Removes the first matched element; the argument has to be passed.
```
 l=[1,2,3]
 l.remove(2)
 print(l)
 # [1,3]
```

reverse() - Reverse the order of the list.

 l= [1,2,3]
 print(l.reverse())
 # [3,2,1]

sort() - Sorts a list.
```
 l=[3,1,2]
 print(l.sort())
 # [1,2,3]
```

String Methods

capitalize() - Capitalizes the first character.

 s="string"
 k=s.capitalize()
 print(k)
 # String

casefold() - Lowers the case of a string.

 s = "String"
 casefold() = k
 print(k)
 # string

center() - Centres the string based on the argument.
```
 s="string"
 k=s.center(10)
 print(k)
 # string
```
count() - Returns the number of occurrences of the value in the string.
```
 s="string"
 k=s.count(r)
 print(k)
 # 1
```

endswith() - Returns true if the string ends with the specified value.
```
 s="string"
 k=s.endswith(g)
 print(k)
 # True
```

find() - Searches the string for a specified value and returns the index of it; if not found, it returns -1.
```
 s="string"
 k=s.find(r)
 print(k)
 # -1
```

index() - Returns the index of a specified value after searching the string for it.
```
 s="string"
 k=s.index("r")
 print(k)
 # 2
```

isalnum() - If all characters in the string are alphanumeric, it will return true; otherwise, it will return false.
```
 s="string2"
 k=s.isalnum()
 print(k)
 # True
```

isalpha() - If all characters in the string are in the alphabet, it will return true; otherwise, it will return false.
```
 s="string"
 k=s.isalpha()
 print(k)
 # True
```

isascii() - Return true if all characters in the string are ASCII characters.
```
 s="string"
 k=s.isascii()
 print(k)
 # True
```

isdecimal() - This function returns True if all of the characters in the string are decimals.
```
 s="\u0033"
 k=s.isdecimal()
 print(k)
 # True
```

isdigit() - If all characters in the string are digits, it will return true; otherwise, it will return false.
```
 s="1234"
 k=s.isdigit()
 print(k)
 # True
```

islower() - If all characters in the string are lower case, it will return True; otherwise, it will return false.
```
 s="string"
 k=s.islower()
 print(k)
 # True
```

isnumeric() - If all characters in the string are numeric, it will return true; otherwise, it will return false.
```
 s="1234"
 k=s.isnumeric()
 print(k)
 # True
```

isprintable() - Returns true if the string contains all printable characters.
```
 s="string n adf"
 k=s.isprintable()
 print(k)
 # False
```

isspace() - Returns true if the string contains no whitespace; otherwise, it returns false.
```
 s="string"
 k=s.isspace()
 print(k)
 # False
```

istitle() - If all of the words in the string begin with capital letters, istitle() returns true; otherwise, it returns false.
```
 "String the Word"
 k=s.istitle()
 print(k)
 # True
```

isupper() - True if all the characters are in upper case; otherwise, it will return false.
```
 s="STRING"
 k=s.isupper()
 print(k)
 # True
```

join() - Converts the elements of an iterable into a string.

 s=["s", "t", "r", "i", "n", "g"]
 k="".join(s)
 print(k)
 # string

ljust() - Returns a left-justified string.

 s="string"
 k=s.ljust(10)
 print(k)
 # denotes a string

lower() - Lowers the case of a string.

 s="StrInG"
 k=s.lower()
 print(k)
 # string

lstrip() - Removes the leftmost portion of the string.
```
 s=" string"
 k=s.lstrip()
 print(k)
 # string
```

replace() - Replace the matching values with the passed argument. It takes two arguments.
```
 s="string"
 k=s.replace("ing","")
 print(k)
 # str
```

rfind() - Searches the string for a given value and returns the last position it was found.
```
 s="stringr"
 k=s.rfind("r")
 print(k)
 # 6
```

rindex() - Searches the string for a specified value and returns the last position where it was found.
```
 s="stringr"
 k=s.rindex("r")
 print(k)
 # 6
```

rjust() - Returns a right-justified version of the string.

 s="string"
 k=s.rjust(10)
 print(k)
 # character string

rstrip() - Remove the appropriate portion of the string.
```
 s="string "
 k=s.rstrip()
 print(k)
 # string
```

split() - Splits the string based on the specified separator (the default is a space) and returns a list.
```
 string="string the word"
 k=s.split()
 print(k)
 # ["string", "the", "word"]
```

splitlines() - splits each line and returns a list of the results.

 s="hello world string"
 k=s.splitlines()
 print(k)
 # ['string', 'hello world']

startswith() - This function looks for the letter in the string and returns True if it begins with the specified letter; otherwise, it returns False.
```
 s="string"
 k=s.startswith("s")
 print(k)
 # True
```

strip() - removes the string's trailing space.

 s=" string "
 k=s.strip()
 print(k)
 # string

swapcase() - swaps the cases so that the lower becomes the upper and the upper becomes the lower.
```
 string = "Word"
 k=s.swapcase()
 print(k)
 A wORD IS #STRING
```

title() - converts all of the word's first letters to uppercase.
```
 string = "word"
 k=s.title()
 print(k)
 String = Word
```

upper() - changes the string's case to upper case.
```
 s="string"
 k=s.upper()
 print(k)
 # STRING
```

zfill() - prefix the number of zeros before the string.
```
 s="string"
 k=s.zfill(7)
 print(k)
 # 0string
```

OOPS

Object-oriented programming is a programming model that organises software design around data and objects rather than functions and logic. An object can be defined as a data field; it has unique attributes and behaviours.

OOPS structure:
- Classes - It is like a combination of bundling data and functionality together. Each class instance can have attributes attached to it for maintaining its state it can also have methods to change its state.
- Objects - An Object is an instance of a Class, an instance is a copy of the class with actual values. Python is object-oriented programming language it mainly focus on functions.
- Methods - A method is a function that belongs to an particular object. For example, list objects have methods called append, insert, remove and sort etc...
- Attributes - Class attributes are class variables that are inherited by every object of a class. The value of class attributes remain the same for every new object.

Principles
- Encapsulation - The binding up of methods and attributes, for example, a class is a combination of attributes and methods.
- Abstraction - It's like a hiding of data; it can also help the developers more easily make additional changes over time.
```
Import ABC from ABC
class ClassName(ABC)
# We can make the actual class abstract by inheriting the ABC class.
```
- Inheritance - It's a concept of reusing the same code to avoid redundancy. This method will force the developer to reduce development time and also ensure high accuracy. There are multiple inheritances.
  - Single - derived from a single base or parent.
  - Multiple - derived from multiple base classes.
  - Multilevel - deriving a class from a derived class that has been derived from a base class.
  - Hierarchical: there are multiple derived classes from a single parent class.
- polymorphism - The term "polymorphism" refers to the ability to use the same method as the parent class.
```
     add(x, y, z) = 0:
     x + y + z = return

     print(add(2, 3))
     # 5
     print(addition(2, 3, 4))
     # 9
```

References

CLI - commands and their uses

viyashdoss — Wed, 01 Feb 2023 17:22:53 +0000

1)What is the difference between Service and Application?

Service(API) is a kind of work/process which is mostly used by other programs, whereas Application(Software) is a service offered to the user or any other application to manage the process/work.

2)What are these wildcards ~, ., .., * and ??

Wildcards are special characters which are used to ease the search process. It is used for identifying multiple items but not identical data.
- ~ Home directory
- . Current working directory
- .. Prev to the current directory
- * Any number of characters.

3)What are the different flags for the kill? Why do we use kill -9 in general?

Kill command is used to kill the process in Linux systems but also we can use it to halt/interrupt/continue the process. To do that we can use the command

kill SignalName/ID PID

4)Are you clear about file permissions? Explain them. chmod and chown commands?

CHMOD cmd is used to alter the permission(Read, Write, Execute) of the file. Two different ways of representation.
- Absolute - CHMOD 755 file.txt
- Symbolic - CHMOD a=rwx file.txt
CHOWN cmd is used to update the user/group of the file.
- To update the user - Sudo CHOWN user filename
- To update user & group - Sudo CHOWN user: group filename

5)Usage of Ctrl+R to search previously run commands, arrow keys and tab autocompletion.

Tab - Autocomplete the word based on what we have typed.
Arrow Keys - up/down keys Navigate to frequently used commands.
CTRL+R - It's like a search box to find the previously ran command.