DEV Community: Roshansahurk

Selenium

Roshansahurk — Fri, 07 Apr 2023 09:57:38 +0000

Selenium is an open-source testing tool that is widely used for automating web browsers.
It provides a suite of tools for automating web applications for testing purposes.

Why Selenium?

There are various other tools for automating web browsers such as Appium, Robot framework, Katalon Studio, Cypress, Jmeter, SoapUI etc.
In recent years, selenium gained popularity because of the following:
- Supports multiple programming languages such as Java, Python, C#, Ruby, JavaScript, and more.
- Supports multiple browsers such as Chrome, Firefox, Edge, Safari, and more.
- Supports various frameworks and tools for test reporting and test management, such as TestNG, JUnit, Maven, Jenkins, and more.
- It offers three main components:
  1. Selenium ID
  2. Selenium WebDriver
  3. Selenium Grid.
- Selenium IDE is a record and playback tool used for creating simple test cases in a browser.
- Selenium WebDriver is a powerful automated testing tool that provides a programming interface to create and execute complex test cases.
- Selenium Grid is a distributed testing tool that allows running tests in parallel on multiple machines and browsers simultaneously.
- We will be mainly focusing on Webdriver.
Note: Selenium 4 and above versions are used here. You should have prior knowledge of Python.

Get started with Selenium

Install
- Open the terminal and the below command:
```
pip install selenium
```
- The installation entirely depends on your usage. You can install it globally as well in your virtual environment.
- Install the below package
```
pip install webdriver-manager 
```
- Why web driver-manager?
  1. The WebDriver Manager automates the process of downloading and configuring WebDrivers for different browsers, which reduces the effort required to manage multiple versions of WebDrivers manually.
- Example:
  - Firefox
```
#Firefox
from selenium import webdriver

from selenium.webdriver.firefox.service import Service as FirefoxService

from webdriver_manager.firefox import GeckoDriverManager

driver = webdriver.Firefox(service=FirefoxService(GeckoDriverManager().install()))
```
- You can find the link in the reference section for different browsers.

Basics of Selenium

1. Open the browser using Selenium.

driver is the object instantiation in the web driver class.

The object *driver will be used to perform various tasks.*

# Chrome
# import webdriver from selenium
from selenium import webdriver

from selenium.webdriver.chrome.service import Service as ChromeService

from webdriver_manager.chrome import ChromeDriverManager

# The below line of code opens up a browser.
driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()))

2. Navigate to the URL in a browser

driver.get(url) is a method to open the webpage in the browser.
driver.forward() moves forward into the browser's history if present.
driver.back() moves back into the browser's history.
You can also open the folder/file in the browser by providing the path of the folder/file instead of url.
```
driver.get("http://www.python.org")

driver.forward()

driver.back()
```

3. Setting the browser size

You can set a custom size/position, fullscreen or maximize the window of the browser.

#Maximise Window
driver.maximize_window()

#FullScreen
driver.fullscreen_window()

#Set Window Size
driver.set_window_size(500,400)

#Set Window Position
driver.set_window_position(x=500,y=400)

#Get Window Size
print(driver.get_window_size())

#Get Window Position
window_pos= driver.get_window_position()
print(window_pos)

#Page refresh command
driver.refresh()

4. Interaction with page

To interact with the pages, or, more specifically, the HTML elements within a page. First of all, we need to find one. WebDriver offers several ways to find elements. For example, given an element defined as:
```
<input type="text" name="passwd" id="passwd-id" />
```

You could find it using any of:

from selenium.webdriver.common.by import By

element = driver.find_element(By.ID, "passwd-id")

element = driver.find_element(By.NAME, "passwd")

element = driver.find_element(By.XPATH, "//input[@id='passwd-id']")

element = driver.find_element(By.CSS_SELECTOR, "input#passwd-id")

Use devtools to get the Id, Name, Xpath or CSS_Selector. These are often refferred as locators.
After finding the element various operations can be performed on the elements such as click, drag and drop, hold, hover, text inside the element, clear the text, toggle, select.

For instance, we will see the common actions performed on the elements.

element.click() # Performs a click on the element 

element.send_keys('some-text') # Adds a text inside the input element

element.clear() # Clears the text in the input element

Perform a drag and drop
```
from selenium.webdriver import ActionChains

element = driver.find_element(By.NAME, "source")
target = driver.find_element(By.NAME, "target")

action_chains = ActionChains(driver)
action_chains.drag_and_drop(element, target).perform()
```
- BONUS: While using actionchains() class always use .perform() at the end to perform the specific action. Actionchains() are used to trigger the mouse events in the browser. If you forget to write .perform(), the mouse events will fail to run. Although it won't through an error, you will not be able to use the mouse events
Moving between windows
- How do you know the window name?
  - Take a look at the javascript or link that opened it:
```
<a href="somewhere.html" target="windowName">Click here to open a new window</a>     
```

driver.switch_to.window("windowName")

Alternatively, you can also find by driver.window_handles
driver.window_handles returns a list with hashcodes of the window, pass the hashcode instead of windowName in the above code. If you are not comfortable with hashcodes then feel free to use the above method.
- BONUS: At times your browser will open a new tab. If you locate that element in the browser without changing the current handle of the browser then it will raise an error. So it is important that when your browser opens a new tab and if you want to work with the element in that tab then switch to that window.

Waits

When a page is loaded by the browser, the elements within that page may load at different time intervals. This makes locating elements difficult: if an element is not yet present in the DOM, a locate function will raise an ElementNotVisibleException exception.
This is where wait comes into the picture to resolve this issue.
There are two types of wait:
1. Implicit wait
2. Explicit Wait
An implicit wait tells WebDriver to poll the DOM for a certain amount of time when trying to find any element (or elements) not immediately available. The default setting is 0 (zero). Once set, the implicit wait is set for the life of the WebDriver object.
```
from selenium import webdriver

driver = webdriver.Firefox()

driver.implicitly_wait(10) # seconds

driver.get("http://somedomain/url_that_delays_loading")

myDynamicElement = driver.find_element_by_id("myDynamicElement")
```

An explicit wait is a code you define to wait for a certain condition to occur before proceeding further in the code. WebDriverWait in combination with ExpectedCondition is one way this can be accomplished.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Firefox()
driver.get("http://somedomain/url_that_delays_loading")

element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "myDynamicElement"))
)

In the code above, Selenium will wait for a maximum of 10 seconds for an element matching the given criteria to be found. If no element is found in that time, a TimeoutException is thrown. By default, WebDriverWait calls the ExpectedCondition every 500 milliseconds until it returns success. ExpectedCondition will return true (Boolean) in case of success or not null if it fails to locate an element.

As we are moving towards the end of this post, you need to close the browser.

# Closes the current session
driver.close()

# Closes all the session
driver.quit()

Conclusion

This is not the end of selenium. There are various other resources to know about selenium.
The above content provided is solely based on getting a basic understanding of selenium.
For more details see the references sections.

References:

How selenium came to existence?
To know more about selenium, read the below documentation:
- Selenium
- Selenium with python
- To know more about Webdriver-manager.

Basics On HTML & CSS

Roshansahurk — Thu, 02 Mar 2023 09:25:02 +0000

This article includes a topic based on HTML and CSS.

Box Model

The box model is a concept in web development that defines how elements on a web page are structured and how their size and position are calculated.
Every HTML element is represented as a rectangular box, which consists of four parts: content, padding, border, and margin.
- Content: Content is the actual information or media that the element contains, such as text, images, or videos.
- Padding: The padding is the space between the content and the border, and it can be used to add extra spacing around the content.
- Border: The border is a line that surrounds the padding, and it can be styled with different colours, widths, and styles.
- Margin: The margin is the space between the border and the neighbouring elements, and it can be used to create gaps between elements.
Together, these four parts of the box model determine the total size of the element.
The total size of the element is then calculated by adding the size of the content, padding, border, and margin.

Inline versus Block Elements

Elements can be classified into two main categories: Inline and block elements.
The distinction between these two types of elements affects how they are rendered on the web page.

Block elementsThe elements that take up the entire width of their parent container and create a new line after the element.

Examples of block elements include headings, paragraphs, lists, and divs.
These elements are often used for larger pieces of content that require their own space on the page.
They can also be styled using CSS to adjust their dimensions, margin, and padding.

Examples of block elements are

<div>                       /*Syntax for divisions*/ 
<h1>, <h2>, <h3>,           /*Syntax for headings*/
<p>                         /*Syntax for paragraphs*/
<ul>, <ol>, <li>            /*Syntax for bullet points*/
<table>, <tr>, <th>, <td>   /*Syntax for table*/
<form>, <button>   /*Syntax to take input from user*/

Inline elements: - The elements that do not create a new line after them and only take up as much width as their content requires.
- Inline elements include text, images, and links.
- These elements are often used for smaller pieces of content that need to be integrated into a larger block element.
- Inline elements can also be styled using CSS, but their width, margin, and padding properties may not behave in the same way as they do for block elements.
- Examples of inline elements are
```
<span>                  /*Syntax for span*/
<a>                     /*Syntax for anchor*/
<img>                   /*Syntax for image*/
<strong>, <em>, <i>     /*Syntax for different styling in a text*/
<br>                    /*Syntax to break lines*/
```
The choice of whether to use a block or inline element depends on the context and purpose of the content.
For example, headings and paragraphs are typically block elements because they require their own space and are often used to separate content.
Meanwhile, links and images are typically inline elements because they are usually embedded within larger blocks of text or other content.

In summary, block and inline elements differ in size, layout, and behaviour on the page. Understanding the difference between these two types of elements is important when designing and styling web pages.

Positioning: Relative/Absolute

Positioning in CSS refers to the process of placing an HTML element precisely in a particular position on a webpage.
It can be used to adjust the location of an element on the page, as well as to layer elements on top of each other.
There are several types of positioning in CSS, But we will discuss Relative and Absolute positioning in this section:

Relative Positioning:
- Relative positioning is a type of positioning in CSS that allows you to position an element relative to its normal position.
- With relative positioning, you can move an element away from its default position, either by shifting it left, right, up or down or by a combination of these movements.
- When an element is positioned relatively, its position is calculated based on its original position in the document flow. This means that if you move a relatively positioned element, the other elements on the page will still flow around it as if it were still in its original position.
- NOTE - When you use relative positioning, the element still takes up the same amount of space as it would in its original position, so it may overlap other elements on the page if it is moved too far.
Absolute Positioning:
- Absolute positioning is a CSS property used to position an element in a specific location relative to its nearest positioned ancestor.
- When an element is positioned absolutely, it is removed from the normal flow of the document and does not affect the position of other elements on the page.
- To use absolute positioning, the parent element must have a position property set to either relative, absolute or fixed. The positioned element is then positioned concerning its parent element's top, right, bottom and left properties.
- Note: When using absolute positioning is that the position of the element is fixed relative to its nearest positioned ancestor, which means that if the parent element is not positioned, the element will be positioned relative to the body element.

Here is an example of how to use absolute positioning:

<!-- HTML FILE -->
<div class="parent">
    <div class="child"></div>
</div>

```css
<!-- CSS FILE  -->
.parent {
position: relative;
width: 200px;
height: 300px;
background-color: gray;
}

.child {
position: absolute;
top: 50px;
left: 50px;
width: 100px;
height: 100px;
background-color: red;
}```

Common CSS structural classes

CSS class selectors are used to apply special styles to an element in certain circumstances or states.
They allow developers to target elements based on their state or position in the document, without using JavaScript or adding extra HTML markup.
Some common CSS pseudo-class selectors include:
- :first-child - selects the first child element of the parent element.
- :last-child - selects the last child element of the parent element.
- :nth-child - selects a specific child element based on its position in the parent element.
- :hover - applies a style when the mouse pointer is over the element.
- :active - applies a style when the element is being activated (e.g., clicked).
- :focus - applies a style when the element has focus (e.g., when it is selected by keyboard navigation).
- :checked - applies a style to an element that is checked, such as a checkbox or radio button.
- :disabled - applies a style to an element that is disabled, such as an input field or button.
By applying different styles to elements based on their state or position, developers can provide visual feedback to users and guide them through the interface.

Common CSS styling classes

Common CSS styling classes are pre-defined classes used to apply specific styling to elements in HTML. These classes allow developers to quickly and easily apply common styles to elements on their web pages without having to write custom CSS code.
Some examples of common CSS styling classes include:
- Text styling classes: These classes allow developers to change the font size, colour, weight, and other text properties. Examples include .text-bold, .text-italic, .text-underline, and .text-uppercase.
- Margin and padding classes: These classes control the spacing around elements on a web page. Examples include .m-0 (margin set to 0), .m-1 (margin set to 1rem), .p-0 (padding set to 0), and .p-1 (padding set to 1rem).
- Border classes: These classes allow developers to add borders to elements on a web page. Examples include .border, .border-top, .border-bottom, and .border-radius.
- Background colour classes: These classes allow developers to set the background colour of elements on a web page. Examples include .bg-primary, .bg-secondary, and .bg-dark.
- Flexbox classes: These classes allow developers to use the CSS Flexbox layout model to position elements on a web page. Examples include .d-flex, .justify-content-center, and .align-items-center.
- Responsive classes: These classes allow developers to apply different styles to elements based on the size of the device being used to view the web page. Examples include .d-sm-block (display as a block on small screens and above), .d-md-flex (display as flex on medium screens and above), and .hidden-lg-up (hide on large screens and above).
By using common CSS styling classes, developers can save time and effort when styling their web pages, while also ensuring a consistent look and feel across their site.

CSS Specificity

CSS specificity is a set of rules that determine which styles will be applied to an element when multiple style rules are targeting the same element.
It is a measure of the weight of a CSS selector, and it determines which rule will be applied if two or more selectors target the same element.
CSS specificity is calculated based on the combination of the different selector types used in the style rule.
Each selector type has a specific value, and the values are added together to determine the specificity of the selector.
The different selector types, in order of increasing specificity, are:
- Type selectors (e.g., p, div, span)
- Class selectors (e.g., .class-name)
- ID selectors (e.g., #id-name)
- Inline styles (e.g., style="colour: red;")
The specificity of a selector can be represented as a four-digit number.
The first digit represents the number of ID selectors, the second digit represents the number of class selectors and attribute selectors, the third digit represents the number of type selectors, and the fourth digit represents the number of pseudo-classes and pseudo-elements.
For example, the selector #header .logo has a specificity of 110, because it has one ID selector and one class selector. On the other hand, the selector body .logo has a specificity of 010, because it has one class selector and one type selector.
When multiple style rules apply to an element, the browser applies the style rule with the highest specificity. If two or more style rules have the same specificity, the browser applies the style rule that comes last in the CSS file or the HTML document.
It is important to keep in mind the specificity of selectors when writing CSS, to avoid unexpected styling behaviour and to ensure that the desired styles are applied to the elements. It is also important to avoid using too many ID selectors, as they have high specificity and can lead to specificity wars and difficult-to-maintain CSS code.

CSS Responsive Queries

CSS responsive queries allow developers to create responsive websites that adjust to different screen sizes and devices. These queries use CSS media queries to apply specific styles based on the device's screen size.
For example, a responsive query may specify that if the screen size is smaller than 768 pixels, the font size should be reduced and the navigation menu should be collapsed. Alternatively, if the screen size is larger than 1200 pixels, the layout should be adjusted to accommodate more content.
To implement responsive queries, developers typically define a set of breakpoints based on common screen sizes, such as 320px for mobile devices, 768px for tablets, and 1200px for desktops. They can then apply styles based on these breakpoints using media queries.
The following code applies a style to all elements with the class "content" when the screen width is less than 768 pixels:
```
@media (max-width: 768px) {
.content {
font-size: 14px;
}
}
```
By using responsive queries, developers can ensure that their websites are optimized for different devices and provide a consistent user experience across all screen sizes.

Flexbox/Grid

Flexbox and Grid are two powerful tools in CSS that allow developers to create complex and responsive layouts.
Flexbox is a one-dimensional layout system that is best suited for arranging items along a single row or column.
- It consists of a container element and one or more child elements, or flex items.
- The container element is defined using the display: flex property and the child elements can be aligned and positioned using a range of flex properties, such as justify-content and align-items.
- Flexbox is great for creating navigation menus, form layouts, and other simple layouts.
Grid is a two-dimensional layout system that allows developers to create grid layouts that are highly responsive and dynamic.
- Grid consists of a container element and a set of grid items that are arranged in rows and columns.
- Grid can be used to create complex layouts that include multiple rows, columns, and nested grids.
- Grid also includes a range of properties that allow developers to control the sizing, positioning, and alignment of grid items.
In general, Flexbox is best suited for simple layouts that require alignment along a single axis, while Grid is better suited for complex layouts that require alignment along two axes.
However, both Flexbox and Grid are highly flexible and can be used in combination to create even more complex layouts.

Common header meta tags

Common header meta tags are used to provide metadata information about an HTML document.
These tags are placed in the head section of an HTML document and help search engines and other applications understand the content and purpose of the page.

Here are some common header meta tags:

/*1.*/ <title> <title>
/*2.*/ <meta name="description" content="description of the page">
/*3.*/ <meta name="keywords" content="comma-separated list of keywords">
/*4.*/ <meta name="viewport" content="width=device-width, initial-scale=1.0">
/*5.*/ <meta http-equiv="refresh" content="5;url=redirect-url">

1. Title tag: - This tag is used to define the title of the document. It is displayed in the title bar of the browser and is also used by search engines to understand the content of the page.


Description tag: This tag is used to provide a brief description of the page's content. Search engines often use this description to display a summary of the page in search results.
Keyword tag: This tag is used to specify a list of keywords that are relevant to the content of the page. Search engines use this information to help rank the page in search results.
Viewport tag: This tag is used to specify the viewport size of the page for mobile devices. It ensures that the page is displayed properly on devices with different screen sizes.
Redirection tag: This tag is used to automatically redirect the page to another URL after a specified time. The number after "content=" specifies the number of seconds before the redirect occurs, and "url=" specifies the URL to redirect to.

References:

For more details, click on the below:

General Questions

Roshansahurk — Thu, 02 Mar 2023 06:36:33 +0000

This section covers the general questions on Cli, Git, Python, Html and CSS.

Q1. How do you delete a specific stash in git?

You can delete a specific stash in git by the command:
```
$ git stash drop stash@{n}
```
Note: This command will permanently delete the stash.
Where n is the index number of the stash.
The indexing of the stash from 0 and goes on.
To search for a specific index in the stash, use the command:
```
$ git stash list
```

Q2. Why do we use "transform: translate" in CSS? Which browser doesn't support this CSS property?

The transform: translate() property in CSS is used to move an element from its original position in the horizontal and/or vertical direction.

Q3. What is the difference between a "terminal" and a "console" in the context of Linux?

Terminal: A terminal is a program that provides a user interface to access the shell, which is the command-line interface of the operating system.
Console: The console is the physical device or interface that allows you to interact with the system directly without any graphical interface.

Q4. What is the difference between "grep" and "find" commands in Linux?

Grep: The grep command is used to search for specific text patterns within files. It can search for a single pattern or multiple patterns using regular expressions.
Find: The find command is used to search for files and directories based on certain criteria, such as file name, date modified, or file type. It can also perform actions on the files found, such as copying, moving, or deleting them.

Q5. If there are 3 items in a row, how do you position the item in the third column to the first column using a grid?

You can use the below command:
```
grid-column:1;
```
grid-column used in grid layouts to define both the start and end positions of a grid item within a grid column.
It accepts two values: the starting grid line and the ending grid line for the item in the column axis.
This command will set the 3 items in a row to the first column.
As an alternative to the above command you can also use the below command.
```
grid-column-start:1;
```
grid-column-start is a CSS property used in grid layouts to define the start position of a grid item within a grid column.

Q6. How can you slice a list in Python?

The word slice means to get a specific piece of an object. In python, slicing presents the specified part of the object.

To put it in more simple words. Here is an example in python:

>>> l1 = ['abcd', 1 , 'hello', True, 45.2, 68]
>>> l1[2:4]
>>> ['hello', True]

The syntax for slicing is:
```
object-name[start:end:step]     
```
- Start: Specify the index where you want to start.
- End: Specify the index up to the required end.
- Step: Specify if you want to skip the slice in steps.

Q7. Why do we need the concept of transactions in SQL? What does it help us to achieve?

Transaction is a sequence of operations performed on a database that is considered to be a single logical unit of work. Transactions can consist of one or more database operations, such as inserting, updating, or deleting records.
Transactions are needed in a database system to ensure data consistency and integrity.
When multiple operations need to be performed together, such as transferring funds from one bank account to another, it is essential to ensure that either all the operations succeed, or none of them does.
Without transactions, a failure in the middle of such operations could leave the database in an inconsistent state, causing data corruption and loss.
To avoid data corruption and loss, transactions are used.

Q8. What is the use of an iframe tag?

An iframe is an HTML element used to embed another HTML document inside the current document.
The Syntax to use the iframe tag is:
```
<iframe src="URL"></iframe>
```

Q9. What is the difference between a descendant and a child selector?

A descendant selector is used to select all elements that are descendants of a specified parent element, regardless of how many levels down the hierarchy they are.
```
div a {
/* CSS rules go here */
}
```
A child selector, on the other hand, only selects direct children of a specified parent element. It uses the > symbol to separate the parent and child elements in the selector.
```
div > a {
/* CSS rules go here */
}
```

Q.10 What is the difference between discard() and remove() in Python?

discard() and remove() method removes the specified item in a set.
The major key difference is discard method doesn't throw an error when the specified key is not present not in the set but the remove method throws an error when the specified key is not present in the set.
ADD-ONS: You will find a similar explanation for some similar commands in the list and dictionary.

Q.11 Can you join a table with itself and if so how?

Yes, a table can be joined with itself, and this is known as a SELF JOIN.
A self-join is useful when a table contains a foreign key that references its primary key.
You can also use INNER JOIN with a different alias to join the table with itself or use sub-queries.

Q.12 What is the difference between a view and a temporary table in SQL?

A view and a temporary table are both database objects, but they serve different purposes and have different characteristics.
A view is a virtual table that is based on the result of a SQL query. It is not a physical table and does not store data itself, but instead retrieves and displays data from one or more underlying tables.
A temporary table is a physical table that is created and used for a specific session or transaction. Temporary tables are usually created for the temporary storage of data that is only needed for a short period.
Temporary tables are not stored permanently in the database and are automatically deleted at the end of the session or transaction.
In summary, views are virtual tables that provide a simplified interface to the data, while temporary tables are physical tables that are used for the temporary storage of data during a session or transaction.

Q13. What is the z-index property in CSS?

The z-index property in CSS is used to control the vertical stacking order of elements on a web page.
It specifies the stack order of an element relative to other elements on the page.
Elements with a higher z-index value are displayed on top of elements with a lower z-index value.
The z-index property can be applied to any positioned element (position: absolute, position: relative, position: fixed, or position: sticky).

SQL Concepts

Roshansahurk — Wed, 22 Feb 2023 06:59:33 +0000

This paper gives an outlook about SQL Concepts and Database .
The concepts discussed in the paper includes ACID, CAP, JOINS, AGGREGATION FILTERS IN QUERIES, NORMALIZATION, INDEXES, LOCKING MECHANISM, DATABASE ISOLATION LEVELS AND TRIGGERS.

ACID

The acronym for ACID are:
- A - Atomicity
- C - Consistency
- I - Isolation
- D - Durability
Before diving into the ACID, we must first see what are transaction.

Transaction

A single task is the smallest unit of processing that cannot be divided any further. The set of tasks collectively is referred to as transactions.
A transaction typically involves one or more database operations, such as inserting, updating, or deleting records in one or more tables. All of these operations are executed as a single unit of work, either all succeeding or all failing, and are usually wrapped in a BEGIN TRANSACTION and COMMIT TRANSACTION statement.
If an error occurs during the transaction, the changes made so far can be rolled back or undone, using a ROLLBACK TRANSACTION statement. This ensures that the database remains in a consistent state and prevents data corruption or loss.
Transactions can also harm performance since they require additional resources and can result in the locking and blocking of data. Therefore, it is important to use transactions judiciously and optimize them for maximum efficiency.

Atomicity

The principle of atomicity is commonly referred to as the 'All or nothing rule', which means that a transaction must be executed entirely or not at all.
If an action is performed on a transaction there are only two possible outcomes whether there is complete execution or the execution is not successful.
It involves the following two operations.
- Abort - Changes made to the database are invisible if a transaction aborts.
- Commit - Changes are shown after a transaction commits.
Atomicity is also known as the 'All or nothing rule'.

Consistency

Consistency refers to the idea that the value must constantly be maintained and the correctness of the data.
For example, Bank statements
- Banks maintain consistent rules to avoid any mishappenings.
To maintain consistency in the database, integrity constraints must be enforced before and after each transaction.

Isolation

It is not necessary that at a time only one transaction would happen.
What if there are numerous transactions? The consistency may break which defeats the whole purpose of being consistent in the database.
Isolation guarantees that numerous transactions can take place simultaneously without changing the database state to become inconsistent. Transactions take place without interruption and independently.
Transactions are isolated from each other to ensure that any changes made to data in one transaction are not visible to other transactions until they are committed to the database.
This property ensures that the execution of transactions concurrently will result in a state that is equivalent to a state achieved these were executed serially in some order.

Durability

Durability refers that data remaining in the database permanently once an operation has been completed.
Data should be durable so that in case of system failure, malfunctions or crash, it can still function.
However, if the data disappears, the recovery manager is now in charge, to ensure that the data remains safe.

CAP Theorem

CAP stands for **Consistency, **Availability and **Partition Tolerance.
- Consistency - Consistency means that every read gets the most recent write or an error.
- Availability - Availability means that every request receives a response without guaranteeing that it contains the most recent write.
- Partition Tolerance - Partition Tolerance means that the system continues to function despite messages being dropped or delayed between nodes.
The CAP theorem states that a distributed data store can provide only two of the following three guarantees: consistency, availability, and partition tolerance.
Sometimes, all three can be provided, but at other times, there may be trade-offs between these guarantees.
Consistency comes at the expense of availability.
Availability comes at the expense of consistency.
When responding to a query, a highly available service may provide the current value on the server, but there is no guarantee that it is the most recent value submitted to the database due to potential delays in transit.
To ensure high consistency, we must wait for the new write or return an error to the query. This means sacrificing availability to ensure the data returned by the query is consistent.

Joins

Join statement is used in SQL to join two or more rows/columns to the table.
The different type of join are INNER JOIN, LEFT JOIN, RIGHT JOIN and FULL OUTER JOIN.
SQL is case-insensitive. To differentiate SQL queries, uppercase has been used.
INNER JOIN - It returns only the matching records from both tables based on the condition provided in the ON clause.
```
SELECT table1.column, table2.column
FROM table1
INNER JOIN table2
ON table1.column = table2.column;
```
LEFT JOIN - It returns all the records from the left table and matching records from the right table. If there are no matching records in the right table, it returns NULL.
```
SELECT table1.column, table2.column
FROM table1
LEFT OUTER JOIN table2
ON table1.column = table2.column;
```
RIGHT JOIN - It returns all the records from the right table and matching records from the left table. If there are no matching records in the left table, it returns NULL.
```
SELECT table1.column, table2.column
FROM table1
RIGHT OUTER JOIN table2
ON table1.column = table2.column;
```
FULL OUTER JOIN - It returns all the records from both tables and matching records where they exist. If there are no matching records in either table, it returns NULL.
```
SELECT table1.column, table2.column
FROM table1
FULL OUTER JOIN table2
ON table1.column = table2.column;
```
NOTE - Here table1 and table2 refers to the name of the table. The name of the table varies from database to database. The same applies to the column also.

Aggregations, Filters in Queries

Aggregate function in SQL returns one value after calculating multiple values in a column.
Various types of Aggregate functions are:
- SUM(arg) - The sum function returns the total sum of the column.
```
SELECT SUM(column_name) FROM table_name WHERE column_name2 = 'value';
```
- COUNT(arg) - The count function returns the total number of occurrences in the column.
```
SELECT COUNT(*) FROM table_name WHERE column_name = 'value';
```
- AVG(arg) - Average function calculates the average of the set of values.
```
SELECT AVG(column_name) FROM table_name WHERE column_name2 = 'value';
```
- MIN(arg) - The Min function returns the minimum value available in the column.
```
SELECT MIN(column_name) FROM table_name WHERE column_name2 = 'value';
```
- MAX(arg) - Max function returns the maximum value available in the column.
```
SELECT MAX(column_name) FROM table_name WHERE column_name2 = 'value';
```
Filters are text strings that we use to specify a subset of the data items in the given conditions.
In the above example filters have been used.
WHERE is the filter used in the above queries
```
WHERE (CONDITION1 OR CONDITION2)
```
More than one condition can be put through the where statement to filter the data in the database.

Normalization

Normalization is the process of restructuring a relational database by a series of so-called normal forms to reduce data redundancy and improve data integrity.
If you have a messy database or unintentionally synthesized one with poor integrity, then database normalization is the solution for you.
Large tables can be divided into smaller tables through the process of normalization.
The goal is to minimize data duplication and eliminate data inconsistencies.
Normalization principles can design efficient and robust databases that are easier to maintain and update.
There are different levels of normalization ranging from the first normal form (1NF) to the fifth normal form (5NF).
- 1NF requires that each column in a table contains indivisible values. Each column must have a unique name and no two rows in the table can be identical.
- 2NF requires that the table is in 1NF and that each non-key column in the table is dependent on the entire primary key, not just part of it.
- 3NF requires that the table is in 2NF and that there are no non-key columns that are dependent on other non-key columns. Specifically, in normalization, non-key columns should only depend on the primary key.
- 4NF requires that the table is in BCNF and that there are no multi-valued dependencies (when a table has multiple independent relationships with another table).
- 5NF requires that the table is in 4NF and that it does not have any lossless decomposition. In other words, it should not be possible to combine two tables and get the original table without losing any information.

Indexes

Indexes is used to improve the performance of queries by providing quick access to data. Indexes load the data quickly instead of loading data.
They can be created on one or more columns and can be created as unique or non-unique.
A unique index ensures that each value in the indexed value is unique.
A non-unique index can have duplicate values.
When a query is executed, the database engine uses the index to quickly locate the relevant rows, reducing the time and resources needed to retrieve data.
The only disadvantage is that they take up storage space and require additional processing time to maintain as data is inserted, updated and deleted.

Locking Mechanism

Locking is a mechanism used by databases to manage concurrent access to data by multiple users or processes.
It prevents conflicts and ensures data integrity by allowing only one user or process to modify a piece of data at a time.
There are two types of locks:
- Shared locks - These allow multiple users to read a piece of data simultaneously.
- Exclusive locks - It allows only one user to modify the data at a time.
When a user attempts to modify a piece of data, the database will first obtain an exclusive lock on the data to ensure that no other user is modifying it at the same time.
Upon committing or rolling back a transaction, the lock is released.
Locking can impact database performance since it requires additional resources and can result in the blocking of data.

Database isolation levels

Database isolation levels are a set of rules that determine how transactions interact with one another in a multi-user database environment.
The isolation level determines how concurrent transactions can access and modify the same data, and how changes made by one transaction are visible to others.
There are four commonly used isolation levels in databases: Read Uncommitted, Read Committed, Repeatable Read, and Serializable.
- Read Uncommitted - The Read Uncommitted isolation level allows transactions to read uncommitted data, which means a transaction can read data modified by another uncommitted transaction.
  - The highest level of concurrency.
  - The lowest level of data consistency.
- Read Committed - The Read Committed isolation level ensures that a transaction reads only committed data, which means a transaction will not read data modified by another uncommitted transaction.
  - A higher level of consistency than Read Uncommitted, but comes with reduced concurrency.
- Repeatable Read - The Repeatable Read isolation level ensures that a transaction reads the same set of data throughout its lifetime, even if other transactions modify the data in the meantime.
  - A higher level of consistency than Read Committed, but reduces concurrency even further.
- Serializable - The Serializable isolation level provides the highest level of consistency, ensuring that transactions execute in a serializable order and that all transactions are isolated from one another.
  - Strongest guarantees of data consistency, but also the lowest level of concurrency.
Choosing the appropriate isolation level depends on the specific requirements of the application.

Triggers

Triggers are database objects that are used to automatically execute a set of SQL statements in response to certain database events or data changes.
They can be used to enforce business rules, audit data changes, maintain referential integrity, and perform other automated tasks.
Triggers are typically defined to execute in response to one of the following events: INSERT, UPDATE, or DELETE. They can be defined to execute either before or after the triggering event occurs.
Triggers can be defined at either the table level or the database level and can be used to enforce complex business rules and data validation.
While triggers can be powerful tools for enforcing data integrity and automating tasks, they can also have an impact on database performance if they are not used appropriately.

References

To know more about the topics discussed above, you can click on the below links.

SOLID Concepts

Roshansahurk — Mon, 20 Feb 2023 06:38:08 +0000

Solid is a principle that is written in conjunction with code to improve the problems of bad code which are rigidity, fragility and non-usability.
Implementing the solid principle into the code helps the programmer to easily add the changes required onto the code with lesser effort.

Why Solid?

In the world of software development, programmers tend to tangle up while making changes in the code.
A good programmer writes readable, clear and concise code.
Even if the quality of the code is good, the programmer could find it hard to make some changes to it.

Why solid should be used?

To understand this let us look at the below example:
- A bank company hires a programmer to make software which stores the credential id and could only be accessed by the customer.
- The programmer makes the software and hands it over to the bank company.
- After using it for a while, the bank company asks the programmer for some changes to it.
- The programmer looks up to the code and do the changes required.
- The highest probability is that the software will crash if the quality of the code is bad.
- He has to make changes to the other modules as well.
- The bigger picture in the development field is that the programmer goes to such lengths for making those small changes.
- If we don't follow solid principles we end up with tight or strong coupling of the code with many other modules/applications.
- Tight coupling causes time to implement any new requirement, feature or bug fixes and sometimes it creates some unknown issues.
Therefore, to resolve such problems an American software engineer and instructor Robert C. Martin came up with a solid principle.

Getting started with Solid

The acronyms for class design principles in the solid are:
- SRP - Single Responsibility Principle
- OCP - Open Close Principle
- LSP - Liskov Substitution Principle
- ISP - Interface Segregation Principle
- DIP - Dependency Inversion Principle

Single Responsibility Principle

"A class should have only one reason to change"

Every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class.
Each class and module focuses on a single task at a time.

If a class has more than one responsibility, it becomes coupled.

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

    def get_name(self):
        pass

class VehicleDB:
    def get_vehicle(self):
        pass

    def type(self, vehicle: Vehicle):
        pass

When designing our classes, we should aim to put related features together, so whenever they tend to change they change for the same reason.

Open Close Principle

"Modules should be open for extension, but closed for modification."

To understand more about the open-close principle let us take an example.
Let’s imagine you have a store, and you give a discount of 20% to your favourite customers using this class.

When you decide to offer double the 20% discount to VIP customers. You may modify the class like this:

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

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

This fails the OCP principle due to the changes made in the module.
To make it follow the OCP principle, we will add a new class that will extend the Discount.

In this new class, we would implement its new behaviour.

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

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

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

You see, extension without modification.

Liskov Substitution Principle

"Derived class must be usable through the base class interface, without the need for the user to know the difference."

Liskov principle is a particular definition of a subtyping relation called behavioural subtyping.
The Liskov substitution principle can be implemented by the following:
- No new exceptions can be thrown by the subtype.
- Clients should not know which specific subtype they are calling.
- New derived classes just extend without replacing the functionality of old classes.
- This principle aims to ascertain that a sub-class can assume the place of its super-class without errors.

If the code finds itself checking the type of class then, it must have violated this principle.

def animal_leg_count(animals: list):
    for animal in animals:
        if isinstance(animal, Lion):
            print(lion_leg_count(animal))
        elif isinstance(animal, Mouse):
            print(mouse_leg_count(animal))
        elif isinstance(animal, Pigeon):
            print(pigeon_leg_count(animal))

animal_leg_count(animals)

The above example does not follow liskov's principle, the following changes should be made to make it follow liskov's principle.

    def animal_leg_count(animals: list):
        for animal in animals:
            print(animal.leg_count())

animal_leg_count(animals)

The animal_leg_count function cares less about the type of Animal passed, it just calls the leg_count method.
All it knows is that the parameter must be of an Animal type, either the Animal class or its sub-class.

The Animal class now have to implement/define a leg_count method and its sub-classes have to implement the leg_count method.

class Animal:
    def leg_count(self):
        pass

class Lion(Animal):
    def leg_count(self):
        pass

animal_leg_count just calls the leg_count method of the Animal type because by contract a sub-class of the Animal class must implement the leg_count function.

Interface Segregation Principle

"No client should be forced to depend on the interface/methods it does not use."

Classes should not have to implement interfaces with methods they don't need.
One large interface should be split into many smaller and relevant interfaces so that the clients can know about the interfaces that are relevant to them.

Let’s look at the below IShape interface

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

    def draw_rectangle(self):
        pass

    def draw_circle(self):
        pass

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

    def draw_rectangle(self):
        pass

    def draw_circle(self):
        pass

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

    def draw_rectangle(self):
        pass

    def draw_circle(self):
        pass

It’s quite funny looking at the code above. Class Rectangle implements methods (draw_circle and draw_square) it has no use of, likewise Square implements draw_circle, and draw_rectangle, and class Circle (draw_square, draw_rectangle).
The classes must implement the new method or an error will be thrown.
We see that it is impossible to implement a shape that can draw a circle but not a rectangle or a square or a triangle.
We can just implement the methods to throw an error that shows the operation cannot be performed.
Clients (here Rectangle, Circle, and Square) should not be forced to depend on methods that they do not need or use.
To make our IShape interface conform to the ISP principle, we segregate the actions into different interfaces.

Classes (Circle, Rectangle, Square, Triangle, etc) can just inherit from the IShape interface and implement their draw behaviour.

class IShape:
    def draw(self):
        raise NotImplementedError

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

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

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

We can then use the I-interfaces to create Shape specifics like Semi Circle, Right-Angled Triangles, Equilateral Triangle, Blunt-Edged Rectangle, etc.

Dependency Inversion Principle

"High-level modules should not depend on low-level modules."

Abstraction should not depend on details. Details should depend on abstraction.
The interaction between high-level and low-level modules should be thought of as an abstract interaction between them.
There comes a point in software development where our app will be largely composed of modules.
When this happens, we have to clear things up by using dependency injection.

High-level components depend on low-level components to function.

class XMLHttpService(XMLHttpRequestService):
    pass

class Http:
    def __init__(self, xml_http_service: XMLHttpService):
        self.xml_http_service = xml_http_service

    def get(self, url: str, options: dict):
        self.xml_http_service.request(url, 'GET')

    def post(self, url, options: dict):
        self.xml_http_service.request(url, 'POST')

Here, Http is the high-level component whereas HttpService is the low-level component.
This design violates DIP A: High-level modules should not depend on low-level level modules. It should depend upon its abstraction.

This Http class is forced to depend upon the XMLHttpService class.

class XMLHttpService(Connection):
    xhr = XMLHttpRequest()

    def request(self, url: str, options:dict):
        self.xhr.open()
        self.xhr.send()

class NodeHttpService(Connection):
    def request(self, url: str, options:dict):
        pass

class MockHttpService(Connection):
    def request(self, url: str, options:dict):
        pass

We can create many Http Connection types and pass them to our Http class without any fuss about errors.

Conclusion

In the field of software development, solid principles are used to achieve flexibility in the code.
One can refactor their codes and revise it again and again very easily.
Implementing the five key principles in the code maintains the reusability of code as well.

References

To know more about solid refers to the below section

Object Oriented Programming

Roshansahurk — Thu, 16 Feb 2023 07:40:37 +0000

Solving a problem by creating objects is one of the most popular approaches in programming this is called object-oriented programming. The concept focuses on using reusable code that implements the dry principle.
Python can be used as a declarative modular programming language as well as being used for imperative programming or full object-oriented programming. Declarative programming is a paradigm in which we focus on what we want to implement. Imperative programming is where we describe the exact steps of how to implement what we want.

Class

A class is a blueprint for how something should be defined it doesn't contain any data it is a template that is used to create instances as per the specifications defined in a template or a blueprint.
```
class Car()
    pass    
```

Object

An object of a class is an instance that is built from a class and that is why it is also called an instance of a class.
An object is an instantiation of a class. When a class is defined, a template is defined and memory is allocated only after object instances. Objects of a given class can invoke the methods available to it without revealing the implementation details to the user which is often called abstraction and encapsulation.
```
# The first letter of the class name should always be a capital letter.
class Car():
    pass

c1 = Car() #c1 is the object of class car. 
```

Distinguishing between class attributes and instance attributes

Class attributes are defined as part of the class definition and their values are meant to be the same across all instances created from that class.
The class attributes can be accessed using the class name or instance name, although it is recommended to use as class name to access these attributes.

The state or data of an object is provided by instance attributes.

class Car():
    pass

if __name__ == "__main__":

    #Instance of a class
    car = Car()

    #Instance attributes
    car.color = 'blue'
    car.miles = 100

We created an instance(car) of our Car class and then added two attributes to this instance: colour and miles.
The attributes added using this approach are instance attributes.

Self

Self is a reference to the instance that is being created. The use of self is to access the instance attributes and methods within the instance method, including the init method.
self is not a keyword and can be anything such as this, that, etc.

It has to be the first parameter of the instance methods.

class Car():

    #class attributes
    c_mileage_units = "Mi"

    def __init__(self, color, miles):
        #Instance Variables
        self.color = color
        self.miles = miles

if __name__ == "__main__":

    #Instance of a class
    car = Car("blue", 1000)

    #Instance attributes
    print(car.color)
    print(car.miles)
    print(car.c_mileage_units)

Constructors:

The constructor does nothing other than initialise the instance of a class.
The purpose of having constructors in a class is to initialise or assign the values to the class or instance level attributes mainly instance attributes whenever an instance of a class is being created.
In Python, the init method is known as the constructor and is always executed when new instances are created.
There are three types of constructors:
- Default constructor
- Parameterized constructor
- Non-parameterized constructor
When we do not include any constructor in a class, then the class will use an empty default constructor.
A parameterized constructor can take one or more arguments and the state of the instance can be set as per the input arguments provided through the constructor method.
A non-parameterized constructor does not take any arguments except a reference to the instance being created.

Methods in a class

There are three types of methods in a class
- Instance method
- Class method
- Static method

Instance methods

They are associated with an instance and need an instance to be created first before executing them they accept the first attribute as a reference to the instance self and can read and update the state of the instance.

Class methods

These methods are declared with the @class method decorator.
These methods don't need a class instance for execution.
For this method, the class reference(cls) will be automatically sent as the first argument.

Static methods

These methods are declared with the @static method decorator.
They don't have access to cls or self-objects.
Static methods are like utility functions that take certain arguments and provide the output based on the argument values.
Static method works like regular functions that we define in modules but are available in the context of the class's namespace.

    class Car():

        #class attributes
        c_mileage_units = "Mi"


        #Constructor
        def __init__(self, color, miles):
            #Instance Variables
            self.color = color
            self.miles = miles

        def print_color(self):
            print(f"color of the car is {self.color}")

        @classmethod
        def print_units(cls):
            print(f"mileage units are {cls.c_mileage_units}") 
            print(f"Class name is {cls.__name__}")   

        @staticmethod
        def print_hello():
            print("Hello from a static method")

    if __name__ == "__main__":

        #Instance of a class
        car = Car("blue", 1000)


        #Instance attributes
        car.print_color()
        car.print_units()
        car.print_hello()

    # We can trigger the instance method using the class name, but we need to pass the instance variable as the first argument.
    # This again explains why we need the self-argument for each instance method.

Advantages of Object-Oriented Programming

Mostly we discuss abstraction, encapsulation, polymorphism and inheritance in the advantages of object-oriented programming.
Abstraction Python is defined as hiding the implementation of logic from the client and using the particular application.
Encapsulation in Python describes the content of bundling data and methods within a single unit example when you create a class it means you are implementing encapsulation.
Class can inherit elements from another class. These elements include attributes and methods of the class from which we inherited under classes commonly known as parent classes. This is known as inheritance.
Polymorphism is the ability of an instance to behave in multiple ways and a way to use the same method with the same name and the same arguments to behave differently following the class it belongs to. It can be implemented in two ways method overloading and method overriding

References

To know more about it click on the below links:

Abstraction, Encapsulation, Inheritance, Polymorphism

String Methods

Roshansahurk — Thu, 16 Feb 2023 07:39:18 +0000

What are Strings?

Strings are the data structures which store a sequence of characters.
Strings are immutable i.e. they cannot be changed.
Ex: "Hello"
"Hello" is a string of characters with characters 'h', 'e', 'l', 'l', and 'o' in it.
A string can be initialised by single quotes and double quotes. It throws an array if used in combinations of single quotes and double quotes.

Initialise a string.

>>> s = 'abcde'
>>> s   #Prints the output
'abcde'

The indexing on a string starts with 0 from the start and -1 from the end.
Accessing a particular index in a string.
```
>>> s = 'Hello'
>>> s[2]
l
>>> s[-4]
e
```

Concatenation in a string.

>>> a = "Python"
>>> b = "3.7"
>>> a + " " + b
"Python 3.7"

Slicing in a string is done with the help of square brackets.
s[start:stop:step]
```
>>> s = 'Pythonist'
>>> s[2:4]
th
```

Helper Functions in strings

string.capitalize()

Returns a copy of a string with the first letter capitalised.
```
>>> s.capitalize()
'Abcde'
```
string.lower()

Return a copy of a string with all the characters in lowercase.
```
>>> a = 'Hello WORLD'
>>> a.lower()
hello world
```
string.upper()

Return a copy of a string with all the characters in lowercase.
```
>>> a.upper()
HELLO WORLD   
```
string.split()

Returns a list with the space-separated elements.
```
>>> a.split()
["Hello", "World"]
```

string.join()

Returns a string by joining the entire set of characters in a list or a tuple.

>>> l1 = ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
>>> ''.join(l1)
'Hello World'

string.swapcase()

Returns a copy of string but with lowercase letters to uppercase and vice versa.
```
>>> a = 'Python'
>>> a.swapcase()
'pYTHON'
```
string.casefold()

Return a copy of a string with all the characters in lowercase. It is the same as the string.lower()
```
>>> a = 'Hello WORLD'
>>> a.casefold()
hello world
```
string.center(width, fill_char)

Returns a copy of the string in the centre with added spaces to the right and left. It takes space as a fill character if nothing is given.
```
>>> s = 'HELLO'
>>> s.center(30, '-')
'------------HELLO-------------'
```
string.count(string)

Returns an integer value stating the number of occurrences of a string in a string.
```
>>> s = 'HELLO'
>>> s.count('L')    
2
```
string.endswith(string)

Returns True if the string end with the specified string.
```
>>> s = 'Python'
>>> s.endswith("on")
True
```
string.index(string)

Returns the index of the first occurrence in a string.
```
>>> s = 'Hello World'
>>> s.index('o')
4
```
string.isalnum()

Returns True if all characters in the string are alphanumeric.
```
>>> s = 'AabcD123'
>>> s.isalnum()
True    
```
string.isalpha()

Returns True if all characters in the string are in the alphabet.
```
>>> s = 'abcd'
>>> s.isalpha()
True
```
string.isdecimal()

Returns True if all characters in the string are decimals.
```
>>> s = '1234'
>>> s.isdecimal()
True
```
string.isdigit()

Returns True if all characters in the string are digits.
```
>>> s = '1234'
>>> s.isdecimal()
True    
```
string.islower()

Returns True if all characters in the string are lowercase.
```
>>> s = 'abcd'
>>> s.islower()
True    
```
string.isupper()

Returns True if all characters in the string are uppercase.
```
>>> s = 'ABCD'
>>> s.isupper()
True    
```

References

To know more about the helper functions in a string, click on the below link.

String Methods

Array Methods

Roshansahurk — Thu, 16 Feb 2023 07:37:51 +0000

Array Methods

What are Arrays?

Arrays are the data structures which store the same data type of elements.
The data type includes integer, float and character values.
Arrays can store more than one item at the same time.
They are an ordered sequence of elements.

Difference between array and list

Arrays and lists are similar.
Arrays store only items that are of the same single data type but lists can store multiple data types.
Other properties are almost identical to each other.

Sample codes

array.array(datatype [array items])

Initialise an array

>>> import array

>>> a = array.array('i', [1, 2, 3, 4, 5, 6])

a.typecode

Return the type of the elements
```
>>> a.typecode
'i'
```
a.itemssize

Returns length in bytes of one array item
```
>>> a.itemsize
4    
```

a.append(element)

Adds a value at the end of an array

>>> a.append(5)

#TO KNOW THE OUTPUT 
>>> a
array('i', [1, 2, 3, 4, 5, 6, 5])

a.count(element)

Number of occurrences of argument in the array
```
>>> a.count(5)
2
```

a.extend(iter)

Append items from an iterable

>>> a.extend([74,54,56])
>>> a
array('i', [1, 2, 3, 4, 5, 6, 5, 74, 55, 56])

a.insert(Index, element)

Inserts an element in the index

>>> a.insert(4, 99)
>>> a
array('i', [1, 2, 3, 4, 99, 5, 6, 5, 74, 55, 56])

a.pop()

Returns the last element and pops out the last element from an array.
On passing an argument in the pop method it removes the element from the index. It takes the argument as an index.
```
>>> a.pop()
56
```

a.reverse()

Reverse an array

>>> a.reverse()
>>> a    
array('i', [55, 74, 5, 6, 5, 99, 4, 3, 2, 1])

a.remove(element)

Removes the first occurrence of the element

>>> a.remove(5)
>>> a
array('i', [55, 74, 6, 5, 99, 4, 3, 2, 1])

Quick Overview of Array methods

Method	Function
a.typecode	Returns the type of element in the list
a.itemsize	Returns the byte capacity of the single item in the array
a.count()	Counts the number of occurrences in the array
a.append()	Appends the value to an array
a.extend	Appends an array to an array
a.insert()	Inserts an element at the given index
a.pop()	Pops out the last element from the array
a.reverse()	Reverses the array
a.remove()	Removes the element from the array

References

To search for the data type, click on the below link.

Data type

Xargs, Printenv, Nano and Pipe

Roshansahurk — Thu, 02 Feb 2023 06:28:00 +0000

Xargs

Xargs stands for extended arguments.
The function of Xargs is to build and execute command lines from standard input.
xargs is used in combination with rm, cp, mkdir, and other similar commands.
The synopsis for using Xargs command is:

xargs [options] [command [initial-arguments]]

Xargs executes the command one or more times with any initial-arguments followed by items read from standard input. The default command used by xarg is /bin/echo. Below are the some basic examples for a better understanding of xargs.

Combine Xargs

Let us consider the below two examples:

 find [location] -name "[search-term]" -type f | xargs [command] 
 find . -name '[search-term]' | xargs grep '[string-to-find-in-files]'

The first example above demonstrates using the find command to find all files. The list of files is then piped to xargs, which uses the reaspective command.
The last example above searched for all the files and piped them to xargs, which then executes the grep command on them.

Printenv

Printenv stands for print environment.
The function of the printenv is to print the values of the specified environment variables.
If no variable is specified, it prints out the name and value pairs.
The synopsis for using printenv command is:
```
printenv [OPTION]... [VARIABLE]... 
```

Let's display the values of specific environment variables.

$ printenv HOME
 /root
$ printenv HOME SHELL
 /root 
 /bin/bash

Nano

Nano is a text editor loaded with several features such as opening multiple files, scrolling per line, undo/redo, syntax coloring, line numbering, and soft-wrapping overlong lines.

The synopsis for using nano command is:

nano '[Complete-name-of-the-file-with-its-extesion]'

Use tab for autocompletion of file name

Commands are entered by using the Control (^) and the Alt or Meta (M-) keys.

Basic Commands :

Command	Explanation
CTRL + V	Scrolls page up.
CTRL + Y	Scrolls page down.
CTRL + A	Lets you jump to the beginning of the line.
CTRL + E	Lets you to jump to the end of the line.
CTRL + G	A Help window will pop out and show you all the available commands.
CTRL + O	To save the file. Nano will ask you to edit or verify the desired file name.
CTRL + K	It cuts the entire selected line to the cut buffer (similar to clipboard).
CTRL + U	To paste the text from the cut buffer into the selected line.
CTRL + C	Shows the current cursor position in the text (line/column/character).
CTRL + X	To exit Nano text editor. It prompts a save request if you made any changes to the file.
ALT + A	To select text. You can combine this command with CTRL + K to cut a specific part of the text to the cut buffer.

Pipe

Pipes are used for interprocess commmunication, i.e. it is used to combine two or more commands.
The output generated by the output acts as an input for another command.
Pipes are denoted by symbol |.

Below are few examples where pipes are used.

cat [name-of-the-file] | less
cat [name-of-the-file] | grep -v a | sort - r

Lets look at the output
1. The cat command is used to open the contents of file.
2. The less command shows the contents of file into a readable format.
3. The grep command is used to find strings and values in a document.
4. Sort command sorts out the contents of a file.
5. In the first example the contents of a file are piped into the less command, which in further opens the file into a more readable format.
6. In the last example the contents of the file are piped into grep. The output produced by grep is piped into sort. The output generated by grep will be specified words. The sort command will sort the output generated by grep in reverse order.
On success, zero is returned.
On error, -1 is returned.
You will see more about in above sections where pipes have been used with xargs.

DEV Community: Roshansahurk

Selenium

Why Selenium?

Get started with Selenium

Install

Basics of Selenium

1. Open the browser using Selenium.

2. Navigate to the URL in a browser

3. Setting the browser size

4. Interaction with page

Waits

Conclusion

References:

Basics On HTML & CSS

Box Model

Inline versus Block Elements

Positioning: Relative/Absolute

Relative Positioning:

Absolute Positioning:

Common CSS structural classes

Common CSS styling classes

CSS Specificity

CSS Responsive Queries

Flexbox/Grid

Common header meta tags

References:

General Questions

Q1. How do you delete a specific stash in git?

Q2. Why do we use "transform: translate" in CSS? Which browser doesn't support this CSS property?

Q3. What is the difference between a "terminal" and a "console" in the context of Linux?

Q4. What is the difference between "grep" and "find" commands in Linux?

Q5. If there are 3 items in a row, how do you position the item in the third column to the first column using a grid?

Q6. How can you slice a list in Python?

Q7. Why do we need the concept of transactions in SQL? What does it help us to achieve?

Q8. What is the use of an iframe tag?

Q9. What is the difference between a descendant and a child selector?

Q.10 What is the difference between discard() and remove() in Python?

Q.11 Can you join a table with itself and if so how?

Q.12 What is the difference between a view and a temporary table in SQL?

Q13. What is the z-index property in CSS?

SQL Concepts

ACID

Transaction

Atomicity

Consistency

Isolation

Durability

CAP Theorem

Joins

Aggregations, Filters in Queries

Normalization

Indexes

Locking Mechanism

Database isolation levels

Triggers

References

SOLID Concepts

Why Solid?

Why solid should be used?

Getting started with Solid

Single Responsibility Principle

Open Close Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

Conclusion

References

Object Oriented Programming

Class

Object

Distinguishing between class attributes and instance attributes

Self

Constructors:

Methods in a class

Instance methods

Class methods

Static methods

Advantages of Object-Oriented Programming

References

String Methods