DEV Community: Manisha Kundrapu

Django Concepts

Manisha Kundrapu — Tue, 04 Apr 2023 12:23:32 +0000

Settings file

1. What is the use of a transaction?

In Django, a transaction is a way of grouping multiple database queries into a single, atomic operation. It ensures that either all the queries are successfully completed, or none of them are, even in the face of errors or unexpected events. This is an important feature for maintaining data integrity and consistency, especially in situations where multiple queries need to be executed together, and errors can occur.

For example, when creating a new user in a Django application, several database queries may be required, including creating a new record in the user table, creating default permissions, and creating related records in other tables. These operations must be executed as a single, atomic unit, and any errors that occur must be properly handled to avoid leaving the system in an inconsistent state.

In Django, you can use the transaction.atomic() context manager to group multiple database queries into a single transaction. Any errors that occur within the context manager will cause the entire transaction to be rolled back. Additionally, Django provides other tools, such as transaction.on_commit(), to perform actions after a transaction is committed, and transaction.rollback() to explicitly roll back a transaction.

Overall, using transactions in Django helps ensure that database operations are performed in a consistent and safe manner, and can help prevent data corruption and loss.

2. Why atomic transactions?

Atomic transactions in Django are used to ensure the integrity and consistency of the database. When multiple operations are performed on a database, such as creating or updating multiple records, it is essential to ensure that all of the operations are completed successfully, or none of them are executed at all.

Django provides a built-in support for database transactions using the atomic() function. When the atomic() function is used, it ensures that all database operations executed within its block are completed successfully, or if any error occurs, then all operations are rolled back to the initial state.

For example, let's say you have two models A and B, and you want to create an instance of A and B simultaneously. Without using a transaction, if there is an error while creating B, A would still be created, leading to an inconsistent state. However, if you use an atomic transaction, either both A and B will be created, or neither will be created.

In summary, atomic transactions in Django are used to ensure that database operations are completed successfully or rolled back to their initial state in case of errors, thus maintaining database consistency and integrity.

3. What is secret key?

In Django, the SECRET_KEY setting in the settings.py file is a value that is used to provide cryptographic signing for various authentication and security features , such as session cookies and password reset tokens. It is a randomly generated string of characters, and is an important security measure that helps protect your application from attacks such as cross-site scripting (XSS) and cross-site request forgery (CSRF). The SECRET_KEY is not the same thing as a user's password or login credentials, and should not be treated as such.

It is important to note that the SECRET_KEY should never be hard-coded into your code or shared publicly. Instead, it should be stored in a secure location and passed to Django through an environment variable or a configuration file that is not checked into version control.

To generate a new SECRET_KEY, you can use Django's built-in get_random_secret_key function, like so:

from django.core.management.utils import get_random_secret_key

SECRET_KEY = get_random_secret_key()

This will generate a new SECRET_KEY that can be used in your settings.py file.

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

Django includes several default apps which are installed and enabled by default when creating a new Django project.

These apps provide core functionality to the framework and include:

django.contrib.admin:
Provides a web-based administrative interface for the application.
django.contrib.auth:
Provides authentication and authorization features for the application.
django.contrib.contenttypes:
Provides content type functionality to the application.
django.contrib.sessions:
Provides session management functionality to the application.
django.contrib.messages:
Provides messaging functionality to the application.
django.contrib.staticfiles:
Provides a way to serve static files like JavaScript, CSS, and images.

Other optional apps that can be installed and used in Django include:

django.contrib.sites:
Provides site-specific functionality to the application.
django.contrib.redirects:
Provides a way to manage URL redirections in the application.
django.contrib.sitemaps:
Lets you specify the URLs that should be included in the site's XML sitemap.
django.contrib.flatpages:
Provides a simple system for creating flat, static pages.
django.contrib.syndication:
Makes it easy to syndicate content from your site with RSS and Atom feeds.

You can also create your own custom apps and include them in your Django project.

5. What is middleware? What are different kinds of middleware ?

In Django, middleware is a way to add extra functionality to the request/response processing pipeline. It sits between the web server and the view, and can modify the incoming request, outgoing response, or perform additional processing in between.

Django middleware can be used for a variety of purposes, such as authentication, caching, logging, compressing response content, and more.

There are different kinds of middleware in Django, including:

Process Request Middleware:
This type of middleware is executed before the view is called and can modify the request or perform additional processing before passing the request to the view.
Authentication Middleware:
This middleware is responsible for authenticating the user and setting the user object in the request object.
Session Middleware:
This middleware adds support for session handling in Django.
Cache Middleware:
This middleware provides caching support to the views.
Middleware for Compression:
This middleware compresses the content of the response to reduce its size and save bandwidth.
Exception Middleware:
This middleware catches and handles exceptions raised during the processing of a request.
Middleware for Response Headers:
This middleware can add or modify response headers.
Middleware for HTTPS:
This middleware redirects the request to HTTPS if the request is made over HTTP.

Django allows developers to write their own custom middleware to add functionality to the request/response pipeline.

Middleware can be added to the middleware stack in the settings file, and they are executed in the order they are defined in the stack.

6. CSRF

Cross-Site Request Forgery (CSRF) is a type of web vulnerability that allows attackers to perform actions on behalf of victims without their knowledge or consent. Django has built-in protection against CSRF attacks.

The CSRF protection in Django is based on a random secret value stored in a CSRF cookie that only the server has access to. This value is included in every form rendered by Django by default as a hidden input field, and is also included in AJAX requests.

To use the CSRF protection in Django, you need to include the {% csrf_token %} template tag in your form. When the form is submitted, Django checks that the value of the CSRF cookie matches the value in the form submission.

If you encounter CSRF verification errors in your Django application, it could be because the CSRF protection middleware is not enabled, or because the CSRF token was not included in the form submission. Make sure that the
{% csrf_token %} tag is included in your form and that the django.middleware.csrf.CsrfViewMiddleware middleware is included in your MIDDLEWARE setting.

It's important to enable the CSRF protection in your Django application to prevent possible CSRF attacks. Disabling the CSRF protection is not recommended, as it can leave your application vulnerable to attacks.

7. XSS

Cross-Site Scripting (XSS) is another type of web vulnerability that can affect Django web applications. It allows an attacker to inject malicious scripts into the application, which can then execute in the context of a legitimate user's web page.

Django provides protection against XSS attacks by automatically escaping dynamic content rendered in templates using the |safe filter. This ensures that any HTML code in the content is converted to HTML entities, which prevents it from being executed as code. You should also avoid using the |safe filter unless you are sure that the content is safe to render as raw HTML.

To further protect your Django application from XSS attacks, you can use the django.middleware.security.SecurityMiddlewaremiddleware, which adds various security-related HTTP headers to the response. Some of these headers can help protect against XSS attacks, such as the X-XSS-Protection header, which enables or disables the browser's built-in XSS protection.

It's important to implement proper security measures to prevent XSS attacks, especially in web applications that deal with sensitive data or handle user authentication. By following best practices and using the available security features provided by Django, you can minimize the risk of an XSS attack on your application.

8. Click Jacking

Clickjacking is a type of security vulnerability where a user is tricked into clicking on a button or link that appears to be legitimate, but is actually hidden on top of another element on the page. This can be used to perform actions on behalf of the user without their knowledge or consent. Django provides built-in protection against clickjacking attacks by setting the X-Frame-Options header to prevent web pages from being embedded in iframes on other websites.

The X-Frame-Options header is a HTTP response header that can be used to control whether a web page can be embedded in an iframe on another website. By setting this header, you can prevent clickjacking attacks by ensuring that your web pages cannot be embedded in iframes on other websites.

In Django, you can set the X-Frame-Options header by configuring the MIDDLEWARE setting in your settings.py file. The following code sets the X-Frame-Options header to DENY, which prevents your web pages from being embedded in any iframes:

MIDDLEWARE = [
    # ...
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

X_FRAME_OPTIONS = 'DENY'

By default, the X-Frame-Options header is set to SAMEORIGIN, which allows your web pages to be embedded in iframes on the same domain. However, if you do not need to embed your web pages in iframes at all, it is recommended to set the header to DENY to provide maximum protection against clickjacking attacks.

In addition to setting the X-Frame-Options header, you can also use JavaScript to prevent clickjacking attacks by detecting whether your web page is being displayed inside an iframe and taking appropriate action. However, this method is less reliable than using the X-Frame-Options header, as it may not work in all browsers and may be disabled by browser extensions or security software.

9. Any other middleware that is there?

AuthenticationMiddleware: This middleware adds the user object to the request object after the user authenticates
CsrfViewMiddleware: This middleware adds protection against CSRF (Cross-Site Request Forgery) attacks to your views by adding a CSRF token
SecurityMiddleware: This middleware adds several security-related HTTP headers to your responses to improve the security of your site, such as X-XSS-Protection, X-Content-Type-Options, and more
SessionMiddleware: This middleware manages sessions for your web application, providing a way to store information between requests for a specific user
CommonMiddleware: This middleware contains several common operations used in web development, such as adding a slash to URLs that don't have one, handling redirects, and more.
Message Middleware: This middleware is used to store and display messages to the user. It can be used to display success messages, error messages, and other feedback to the user.
Cache Middleware: This middleware is used to cache responses from your Django application. It can improve the performance of your application by reducing the number of requests to the server.
GZip Middleware: This middleware is used to compress responses from your Django application. It can reduce the size of responses and improve the performance of your application.
Locale Middleware: This middleware is used to set the language and localization settings for your Django application. It can detect the user's preferred language and display content in that language.

These are just a few examples of the middleware available in Django. You can also write your own custom middleware to add specific functionality to your application.

10 . What is WSGI?

WSGI stands for "Web Server Gateway Interface." It is a standard interface between web servers and Python web applications or frameworks, including Django. The purpose of WSGI is to provide a simple and universal interface that allows any web server to communicate with any Python web application or framework.

When a client requests a web page from a Django application, the web server sends the request to the WSGI server, which then forwards the request to the Django application. The Django application processes the request, generates a response, and sends the response back to the WSGI server. The WSGI server then sends the response back to the web server, which finally sends the response back to the client.

In Django, the WSGI server is typically provided by a third-party library, such as uWSGI or Gunicorn. Django includes a built-in WSGI handler in the form of the django.core.handlers.wsgi.WSGIHandler class, which is responsible for handling requests and generating responses.

Using WSGI allows Django applications to be deployed on a wide variety of web servers, including Apache, Nginx, and many others. It also allows for greater flexibility in configuring and optimizing the web server and the Python application separately.

Models file

1. What is ondelete Cascade ?

In Django, on_delete is an argument that can be used to specify the behavior of a foreign key relationship when the referenced object is deleted. on_delete specifies what should happen to the objects that have a foreign key pointing to the deleted object.

on_delete can take several values, including:

models.CASCADE:
When an object referenced by a foreign key is deleted, all objects that have a foreign key pointing to it will also be deleted. This can result in a cascading delete effect.
models.PROTECT:
When an object referenced by a foreign key is deleted, the deletion will be prevented if there are any objects that have a foreign key pointing to it. This can prevent accidental deletion of important data.
models.SET_NULL:
When an object referenced by a foreign key is deleted, the foreign key on all related objects will be set to NULL. This can result in data inconsistency if the foreign key is required.
models.SET_DEFAULT:
When an object referenced by a foreign key is deleted, the foreign key on all related objects will be set to its default value.
models.SET():
When an object referenced by a foreign key is deleted, the foreign key on all related objects will be set to the specified value.

For example, if we have a Book model with a foreign key to an Author model, and we set on_delete=models.CASCADE, then when an author is deleted, all books written by that author will also be deleted.

It is important to choose the appropriate on_delete behavior based on the requirements and relationships of your data.

2. A broad understanding of Fields and Validators available.

In Django, fields are used to define the type of data that can be stored in a model. There are several built-in field types available in Django, such as CharField, TextField, IntegerField, FloatField, DateField, and DateTimeField, among others. Additionally, Django provides support for defining custom fields that can be used in a model.

Validators, on the other hand, are used to ensure that the data entered by a user is valid and meets certain criteria. Validators can be applied to individual fields or to a form as a whole. Django provides several built-in validators that can be used to check if a field is required, if it has a maximum or minimum value, if it matches a regular expression, among others. Additionally, custom validators can be defined and used to validate form data based on specific business rules.

Overall, fields and validators are important concepts in Django and are used to define the structure and behavior of models and forms. By understanding the available fields and validators, developers can create robust and secure applications that handle user data in a reliable way.

Here is a brief overview of some of the most common fields and validators available in Django:

Fields:

CharField: A field that can store a string of up to a specified maximum length.
TextField: A field that can store a longer string of text.
IntegerField: A field that can store an integer.
BooleanField: A field that can store a boolean value.
DateTimeField: A field that can store a date and time.
ForeignKey: A field that defines a many-to-one relationship with another model.
ManyToManyField: A field that defines a many-to-many relationship with another model.

Validators:

MaxValueValidator: A validator that ensures that the input value is less than or equal to a specified maximum value.
MinValueValidator: A validator that ensures that the input value is greater than or equal to a specified minimum value.
EmailValidator: A validator that ensures that the input value is a valid email address.
RegexValidator: A validator that ensures that the input value matches a specified regular expression pattern.
URLValidator: A validator that ensures that the input value is a valid URL.
MaxLengthValidator: A validator that ensures that the input value is shorter than or equal to a specified maximum length.

3. Understanding the difference between Python module and Python class?

In Python, a module is a file containing Python code, while a class is a code template for creating objects that define the properties and methods of those objects.

Here are some key differences between Python modules and classes:

A module is a file containing Python code, while a class is a code template for creating objects.
A module can contain multiple classes, functions, and variables, while a class is a specific construct for defining object behavior and properties.
Modules are typically used to organize related code into a single file, while classes are used to define the structure and behavior of objects.
Modules are imported using the import statement, while classes are instantiated using the class keyword.
In Django, modules are commonly used to organize related functionality into separate files, such as models, views, forms, and templates. Classes are used to define the behavior and properties of those objects.
For example, in a Django application, we might have a module called models.py that defines several classes, such as User, Post, and Comment, each representing a different type of object in the application. We can then import these classes into other modules, such as views.py, to define the behavior of those objects in response to HTTP requests.

Django ORM

1. Using ORM queries in Django Shell

Django's ORM provides an interactive shell that allows you to experiment with database queries and interact with the database directly from the command line.

Here's how you can use the ORM queries in Django shell:

Open your terminal and navigate to the root directory of your Django project.
Activate your virtual environment, if you have one.
Type python manage.py shell to open the Django shell.
Once you're in the shell, you can start typing ORM queries to interact with your database. For example, you could retrieve all of the objects from a particular model using the following command:

>>> from myapp.models import MyModel
>>> MyModel.objects.all()

This will return a QuerySet object containing all of the objects in the MyModel table.

You can also filter the QuerySet based on certain criteria. For example, to retrieve all of the objects in the MyModel table where the name field is equal to "John", you could use the following command:

>>> MyModel.objects.filter(name='John')

You can chain multiple filters together to refine your query even further. For example, to retrieve all of the objects in the MyModel table where the name field is equal to "John" and the age field is greater than 30, you could use the following command:

>>> MyModel.objects.filter(name='John', age__gt=30)

You can also use other ORM methods such as exclude(), order_by(), values(), and annotate() to further manipulate your QuerySet.

When you're finished with the shell, you can exit by typing exit() or pressing Ctrl+D.

Overall, using the Django shell with ORM queries is a powerful way to interact with your database and test out queries before incorporating them into your application.

2. Turning ORM to SQL in Django Shell

Django's ORM provides a way to translate ORM queries into SQL statements.

This can be useful for debugging or optimizing queries, as it allows you to see the actual SQL that's being executed by the database.

Here's how you can turn ORM queries into SQL in the Django shell:

Once you're in the shell, you can start typing ORM queries to interact with your database.

For example, you could retrieve all of the objects from a particular model using the following command:

>>> from myapp.models import MyModel
>>> MyModel.objects.all()

To see the SQL that's being executed for this query, you can call the query attribute on the QuerySet object, like this:

>>> print(MyModel.objects.all().query)

This will print out the SQL that's being executed to retrieve all of the objects from the MyModel table.

You can also turn more complex ORM queries into SQL by calling the query attribute on the QuerySet object.

For example, to see the SQL that's being executed for a filtered query, you could use the following command:

>>> print(MyModel.objects.filter(name='John', age__gt=30).query)

This will print out the SQL that's being executed to retrieve all of the objects in the MyModel table where the name field is equal to "John" and the age field is greater than 30.

Overall, turning ORM queries into SQL statements in the Django shell is a powerful way to debug and optimize your queries. It allows you to see the exact SQL that's being executed by the database, which can be useful for identifying performance bottlenecks or other issues with your queries.

3. What are Aggregations?

Aggregations in Django are a way to perform various mathematical operations on a set of values within a QuerySet. They allow you to calculate statistics and summarize data based on certain criteria, such as the average or sum of a particular field in the database table. Django provides a set of built-in aggregation functions that you can use in your code.

Here are some of the built-in aggregation functions in Django:

Avg: Calculates the average value of a particular field in the QuerySet.
Count: Returns the number of objects in the QuerySet.
Max: Returns the maximum value of a particular field in the QuerySet.
Min: Returns the minimum value of a particular field in the QuerySet.
Sum: Calculates the sum of a particular field in the QuerySet.

You can use these aggregation functions in combination with other QuerySet methods to create complex queries.

For example, you could use the filter() method to narrow down the QuerySet to a specific subset of objects, and then use the Avg() function to calculate the average value of a particular field in that subset.

Here's an example of using the Avg() function to calculate the average price of all the products in a database table:


from myapp.models import Product

average_price = Product.objects.all().aggregate(Avg('price'))

This code retrieves all the objects from the Product table and calculates the average value of the price field using the Avg() function.

The result is returned as a dictionary, with the name of the aggregation function as the key and the result as the value.

Overall, aggregations are a powerful way to perform calculations and summarize data within a QuerySet in Django. They allow you to create complex queries and extract useful insights from your data.

4. What are Annotations?

In Django, annotations are a way to provide additional information or computations on each object in a QuerySet. They allow you to enrich the data returned from a queryset with additional fields that are not part of the database schema. Annotations are similar to aggregations in that they both operate on subsets of data, but the difference is that annotations are applied to each object in the QuerySet individually.

Annotations are performed using the annotate() function in Django, and can be used with a wide range of aggregation functions, such as Count(), Sum(), Avg(), Max(), and Min(). The resulting QuerySet will contain the original objects, as well as the annotated fields.

Here's an example of using the annotate() function to perform a count of related objects for each object in a queryset:

from myapp.models import Author, Book
book_counts = Author.objects.annotate(num_books=Count('book'))
for author in book_counts:
    print(author.name, author.num_books)

In this example, Author and Book are Django models. We use the annotate() function to annotate the QuerySet with a field called num_books, which is a count of related Book objects for each Author. We then iterate over the results and print out the author name and the number of books they have written.

Overall, annotations are a powerful way to add additional data to a QuerySet based on calculations or aggregations. They allow you to perform complex operations on your data without modifying the underlying database schema, and can be a useful tool for generating reports or visualizations based on your data.

5. What is a migration file? Why is it needed?

In Django, a migration file is an autogenerated Python script that represents a set of changes to your database schema. It contains instructions for creating, modifying, or deleting database tables, columns, indexes, and other database schema objects.

Migration files are needed for several reasons:

They allow you to version control your changes to the database schema, which makes it easier to track changes and revert to previous versions if necessary.
They make it easy to deploy changes to the database schema to production systems, because you can simply apply the migration files to the production database.
They provide a way to update the database schema in a consistent and reliable manner without having to manually make changes to the database or write custom scripts.

When you create a new model or modify an existing one in Django, you can generate a new migration file using the makemigrations management command. This command analyzes the changes you've made to your models and generates a new migration file that captures those changes. You can then apply the migration using the migrate management command, which updates your database schema to reflect the changes in the migration file.

Here's an example of generating and applying a migration in Django:

# Create a new model
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

# Generate a new migration file
python manage.py makemigrations

# Apply the migrations
python manage.py migrate

In this example, we create a new Book model with three fields, and then generate a new migration file using the makemigrations command. This command analyzes the changes we've made to our models and generates a new migration file that captures those changes. We can then apply the migration using the migrate command, which updates our database schema to reflect the changes in the migration file.

Overall, migration files are a critical component of the Django ORM. They allow you to manage changes to your database schema over time, version control those changes, and apply them in a consistent and automated way. Without migrations, managing changes to your database schema can be a time-consuming and error-prone process.

6. What are SQL transactions? (non ORM concept)

In general, an SQL transaction is a series of queries executed as a single unit of work, where all of the queries either succeed together or fail together. In Django, SQL transactions are used to ensure that database operations are applied atomically and reliably.

When you perform a database operation in Django, it is typically executed within a transaction. Transactions can ensure that changes to the database are atomic, meaning that either all of the changes are applied, or none of them are. If a transaction fails, all of the changes made within the transaction are rolled back, so that the database remains in a consistent state. This is important for ensuring data integrity and consistency.

In Django, you can control transactions using the transaction.atomic() decorator, which wraps a block of database operations in a transaction. There are also lower-level functions like transaction.commit() and transaction.rollback() which allow you to explicitly commit or rollback a transaction.

Overall, transactions are an important concept in SQL and databases in general, and they are essential for ensuring data consistency and integrity in Django applications as well.

7. What are atomic transactions?

In the context of Django, atomic transactions refer to a way of ensuring the atomicity of database transactions. Atomicity is one of the defining properties of database transactions, and it means that a set of database operations must be executed as a single, indivisible unit of work. This ensures that the database is always in a consistent state, even if there are errors or interruptions during the transaction.

Django provides a single API , transaction.atomic(), to control database transactions. When you use transaction.atomic(), Django starts a transaction before calling a view function, and if the view produces a response without errors , Django commits the transaction. If there are any errors, Django rolls back the transaction, undoing any changes that were made to the database during the transaction.

Using atomic transactions in Django is important any time you have a multi-step process that involves making changes to the database. By using atomic transactions, you can ensure that the database remains in a consistent state, even if errors occur during the transaction.

References

https://docs.djangoproject.com/en/3.2/topics/settings/

https://docs.djangoproject.com/en/3.2/topics/http/middleware/

https://docs.djangoproject.com/en/3.2/ref/csrf/

https://docs.djangoproject.com/en/3.2/topics/security/#cross-site-scripting-xss-protection

https://docs.djangoproject.com/en/3.2/topics/security/#clickjacking-protection

https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/

https://docs.djangoproject.com/en/4.1/topics/db/aggregation/

Revision 10-03-2023

Manisha Kundrapu — Fri, 10 Mar 2023 07:05:01 +0000

1. In JavaScript how do you check whether an object is an array or not?

In JavaScript, you can check whether an object is an array or not using the Array.isArray() method.

2. Is the data list tag and select tag the same?

While the and HTML tags are both used to present a list of options to the user, they are not the same.

The tag is used to create a dropdown list of options that the user can select from. When the user clicks on the dropdown, a list of options is displayed and the user can choose one of the options. The selected option is then displayed in the dropdown.

The tag, on the other hand, is used to create a list of options that are displayed as suggestions while the user is typing in an input field. When the user types a character in the input field, a list of suggested options is displayed below the input field. The user can then select one of the suggested options, or continue typing to refine the suggestions.

3. When merge conflict occurs in git?

A merge conflict in Git occurs when two or more developers make changes to the same part of a file, and those changes conflict with each other.

4. Why do we use the typeof operator in JavaScript?

The typeof operator is used to determine the data type of a given value or expression.

It returns a string indicating the type of the operand.

5. What is the difference between "===" and "==" in JavaScript?

The == operator checks whether the values of two operands are equal or not, regardless of their data types. If the values are equal, it returns True. If they are not equal, it returns False.

The === operator also compares two values for equality, but it does take their data type into account. This means that if the two values have different data types, the comparison will return false.

6. What is the difference between CSS border and outline?

CSS border properties allow us to set the style, color, and width of the border.

CSS outline property allows us to draw a line around the element, outside the border.

7. When do we use let and const instead of var in JavaScript?

var declarations are globally scoped or function scoped while let and const are block scoped.

var variables can be updated and re-declared within its scope.

let variables can be updated but not re-declared, const variables can neither be updated nor re-declared.

They are all hoisted to the top of their scope.

8. What is the difference between shared lock and exclusive lock in a transaction?

A shared lock allows multiple transactions to read the same data concurrently, but only one transaction can modify the data at a time.

An exclusive lock allows a single transaction to modify the data while blocking all other transactions from reading or modifying it.

9. What is hoisting in JavaScript?

Hoisting is a mechanism where variable and function declarations are moved to the top of their respective scopes, before the code is executed. This means that variables and functions can be used in code before they are declared, without causing a syntax error.

10. How is user authentication data fetched from forms in web pages?

User authentication data can be done using JWT where it will be added as a middleware in the backend to check the credentials that is stored in the backend in the form of token.

In a JWT-based authentication system, user authentication is done using the following steps:

The user enters their credentials into a form on a web page and submits the form.
The server verifies the user's credentials and, if they are valid, generates a JSON Web Token (JWT) containing a payload with the user's information (such as their user ID, role, and any other relevant data) and signs it using a secret key.
The JWT is then returned to the client and is included in all subsequent requests made by the client.
The backend typically has a middleware (or multiple middlewares) that are responsible for handling user authentication.
When a request is received by the backend, the JWT is extracted from the request and verified using the same secret key that was used to sign it.
If the JWT is valid, the user is considered authenticated and the request is processed.
If the JWT is invalid (e.g., because it has been tampered with or has expired), the user is considered unauthenticated and the request is rejected.

11. What is the git command to update username and email locally?

git config user.name "NewUserName"
git config user.email "new.email@example.com"

12. What is an expression and statement in JavaScript?

An expression is any piece of code that can be evaluated to produce a value.

For example, 5 + 3 is an expression that evaluates to the value 8.

Other examples of expressions include variable references, function calls, and logical operators.

A statement, on the other hand, is a complete unit of code that performs some action.

It typically ends with a semicolon ;.

Examples of statements in JavaScript include variable declarations, function declarations, loops, conditional statements, and assignments.

Here are some examples to illustrate the difference between expressions and statements:


// Expression example
let sum = 5 + 3; // The expression "5 + 3" evaluates to the value 8

// Statement example
if (sum === 8) {
  console.log("The sum is 8!"); // The entire "if" block is a statement that logs a message to the console
}

In this example, 5 + 3 is an expression that is assigned to the variable sum, which is a statement. The if block is a statement that includes an expression (sum === 8) as its condition, and another statement (console.log()) as its body.

HTML CSS Concepts

Manisha Kundrapu — Thu, 02 Mar 2023 06:48:34 +0000

The following are some of the concepts that are included :

Box Model
Inline versus Block Elements
Positioning: Relative/Absolute
Common CSS structural classes
Common CSS syling classes
CSS Specificity
CSS Responsive Queries
Flexbox/Grid
Common header meta tags
Open Graph Tags

1. Box Model

According to the box model concept, every element on a page is a rectangular box and may have width, height, padding, borders, and margins.

It refers to the way in which a box element is rendered on a web page.

It consists of the content area, padding area, border area, and margin area.

Here is a breakdown of each component of the box model:

Content area:

This is where the actual content of the element is displayed.

The content area is determined by the height and width properties.

Padding area:

This is the space between the content and the border.

Padding is used to add space around the content of an element.

The padding area is determined by the padding property.

Border area:

This is the area around the padding and content.

The border is used to add a border around an element.

The border area is determined by the border property.

Margin area:

This is the space between the border and the outside edge of the element.

Margin is used to add space between elements.

The margin area is determined by the margin property.

Total width:

margin-right + border-right + padding-right + width +
padding-left + border-left + margin-left

Total height:

margin-top + border-top + padding-top + height +
padding-bottom + border-bottom + margin-bottom

Here are some examples of how the box model is used in CSS:

Example 1: Adding padding and border to an element

<div class="box">
  This is some text in a box.
</div>

.box {
  padding: 10px;
  border: 1px solid black;
}

In this example, we've added padding and a border to the div element.

The padding property adds 10 pixels of space around the content of the element, and the border property adds a 1-pixel border around the element.

Example 2: Setting the height and width of an element

<div class="box">
  This is some text in a box.
</div>

.box {
  width: 200px;
  height: 100px;
  border: 1px solid black;
}

In this example, we've set the width and height properties of the div element.

This determines the size of the content area of the element.

We've also added a 1-pixel border around the element.

Example 3: Adding margin to an element


<div class="box1">
  This is box 1.
</div>
<div class="box2">
  This is box 2.
</div>

.box1 {
  border: 1px solid black;
  margin: 10px;
}

.box2 {
  border: 1px solid black;
  margin: 20px;
}

In this example, we've added margin to two div elements.

The margin property adds space between the border of the element and the next element on the page.

In this case, box1 has a margin of 10 pixels and box2 has a margin of 20 pixels.

2. Inline versus Block Elements

In HTML and CSS, elements can be classified as either inline or block elements, depending on how they are displayed on the webpage.

Block Elements:

Block-level elements are those which create a rectangular block on the webpage that occupies the entire width of their parent container.

Examples of block-level elements include div, p, h1, ul, ol, table, and form.

Block-level elements can have margin, padding, and borders applied to them, and they will start on a new line.

<div>
  <h1>This is a heading</h1>
  <p>This is a paragraph.</p>
  <ul>
    <li>List item 1</li>
    <li>List item 2</li>
  </ul>
</div>

In this example, the div, h1, p, and ul elements are all block-level elements, and will each start on a new line, taking up the full width of their parent container.

Inline Elements:

Inline elements are those which are displayed inline with the text.

Examples of inline elements include a, span, img, and button.

Inline elements do not start on a new line, and their width is determined by their content.

<p>This is a paragraph with an <a href="#">inline link</a>.</p>

In this example, the p and a elements are both inline.

The a element is displayed inline with the text of the paragraph, and does not start on a new line.

3. Positioning: Relative/Absolute

In CSS, positioning refers to the way elements are positioned on the web page.

There are different types of positioning available in CSS, including relative and absolute positioning.

Relative Positioning:

Relative positioning is the default positioning of elements on a web page.

With relative positioning, an element is positioned relative to its normal position in the document flow.

This means that the element will still take up space in the normal document flow, but it can be moved around using CSS properties such as top, bottom, left, and right.

div {
  position: relative;
  top: 20px;
  left: 50px;
}

In this example, the div element is set to
position: relative, which means it will still take up space in the normal document flow.

However, it has also been moved 20 pixels down and 50 pixels to the right using the top and left properties.

Absolute Positioning:

Absolute positioning allows an element to be positioned relative to its nearest positioned ancestor, or relative to the initial containing block if no positioned ancestor is found.

With absolute positioning, the element is taken out of the normal document flow, and it will not affect the position of other elements on the page.

div {
  position: absolute;
  top: 20px;
  left: 50px;
}

In this example, the div element is set to
position: absolute, which means it will be taken out of the normal document flow.

It has also been positioned 20 pixels down and 50 pixels to the right of its nearest positioned ancestor element.

It's important to note that if an element is absolutely positioned, its position will be fixed relative to the browser window, and will not change if the user scrolls the page.

This can be useful for creating fixed position elements such as navigation bars or headers.

4. Common CSS structural classes

There are several common CSS structural classes that are used to style web page elements.

Here are some examples:

Container:

This class is used to define the outermost element of a web page.

It is typically used to set the maximum width of the page and center its content.

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

Grid:

This class is used to create a grid layout for a web page.

It is typically used to divide the page into rows and columns to organize content.

.grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-gap: 20px;
}

Flex:

This class is used to create a flexible layout for a web page.

It is typically used to align and distribute elements within a container.

.flex {
  display: flex;
  justify-content: center;
  align-items: center;
}

Header:

This class is used to style the header section of a web page.

It is typically used to set the background color, font size, and font style of the heading.

.header {
  background-color: #333;
  color: #fff;
  font-size: 24px;
  font-family: Arial, sans-serif;
}

Navigation:

This class is used to style the navigation menu of a web page.

It is typically used to set the background color, font size, and font style of the menu items.

.navigation {
  background-color: #f1f1f1;
  font-size: 16px;
  font-family: Arial, sans-serif;
}

Footer:

This class is used to style the footer section of a web page.

It is typically used to set the background color, font size, and font style of the footer.

.footer {
  background-color: #333;
  color: #fff;
  font-size: 16px;
  font-family: Arial, sans-serif;
  text-align: center;
  padding: 20px;
}

Section:

This class is used to create a section of a web page.

It is typically used to group related content together and apply styling to the section as a whole.

.section {
  background-color: #f1f1f1;
  padding: 20px;
}

Button:

This class is used to style a button element on a web page.

It is typically used to set the background color, font size, and font style of the button.

.button {
  background-color: #333;
  color: #fff;
  font-size: 16px;
  font-family: Arial, sans-serif;
  border: none;
  padding: 10px 20px;
  border-radius: 5px;
  cursor: pointer;
}

Form:

This class is used to style a form element on a web page.

It is typically used to set the width, background color, and padding of the form.

.form {
  width: 100%;
  background-color: #f1f1f1;
  padding: 20px;
}

Card:

This class is used to create a card element on a web page.

It is typically used to group related content together and apply styling to the card as a whole.

.card {
  background-color: #fff;
  border: 1px solid #ccc;
  border-radius: 5px;
  box-shadow: 0 0 5px rgba(0, 0, 0, 0.1);
  padding: 20px;
  margin: 20px;
}

In this example, we've set the background color of the card to white, added a 1-pixel solid border with a light gray color, and set the border radius to 5 pixels to give the card rounded corners.

We've also added a box shadow to give the card a slight drop shadow effect.

Finally, we've added padding and margin to create space between the content of the card and other elements on the page.

To use the "card" class in HTML, you would simply add the "card" class to a div element that contains the content you want to display in the card.

Here's an example:

<div class="card">
  <h2>Card Title</h2>
  <p>This is some example content for the card.</p>
  <button>Click me</button>
</div>

In this example, we've created a div element with the "card" class and added a heading, paragraph, and button element inside it.

When we view the page in a web browser, the content will be displayed inside a card with the styling we defined in the CSS.

5. Common CSS syling classes

CSS styling classes are used to apply a particular style or effect to an HTML element.

Here are some commonly used CSS styling classes:

Text styles:

These classes are used to define the font size, font weight, font family, color, and text alignment of text content.

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

.text-bold {
  font-weight: bold;
}

.text-large {
  font-size: 24px;
}

.text-serif {
  font-family: serif;
}

.text-muted {
  color: #999;
}

Background and color:

These classes are used to define the background color and text color of an HTML element.

.bg-primary {
  background-color: #007bff;
  color: #fff;
}

.bg-secondary {
  background-color: #6c757d;
  color: #fff;
}

.bg-light {
  background-color: #f8f9fa;
}

.bg-dark {
  background-color: #343a40;
  color: #fff;
}

Borders:

These classes are used to define the border style, width, color, and radius of an HTML element.

.border {
  border: 1px solid #ccc;
}

.border-top {
  border-top: 1px solid #ccc;
}

.border-radius {
  border-radius: 5px;
}

Padding and margin:

These classes are used to define the padding and margin of an HTML element.

.p-4 {
  padding: 16px;
}

.m-4 {
  margin: 16px;
}

Display and positioning:

These classes are used to control the display and positioning of an HTML element.

.d-flex {
  display: flex;
}

.d-inline-block {
  display: inline-block;
}

.position-relative {
  position: relative;
}

.position-absolute {
  position: absolute;
  top: 0;
  right: 0;
}

Hover and active states:

These classes are used to apply styles to an HTML element when the user hovers over or clicks on it.

.hover-bg-primary:hover {
  background-color: #007bff;
  color: #fff;
}

.active-bg-primary:active {
  background-color: #0062cc;
  color: #fff;
}

These are just a few examples of the many CSS styling classes available.

By combining these classes and customizing their properties, you can create a wide range of styles and effects for your web pages.

6. CSS Specificity

CSS specificity is a measure of how specific a selector is in targeting a particular HTML element.

It determines which styles are applied to an element when there are conflicting styles defined in different stylesheets or within the same stylesheet.

CSS selectors have different levels of specificity based on the elements, classes, and IDs that they target.

Here's a breakdown of how specificity is calculated:

Element selectors have the lowest specificity and are worth 1 point.
Class selectors are worth 10 points.
ID selectors are worth 100 points.
Inline styles have the highest specificity and are worth 1000 points.

When multiple selectors target the same element, the selector with the highest specificity is applied.

For example, if you have the following CSS:

p {
  color: red;
}

#paragraph {
  color: blue;
}

And this HTML:

<p id="paragraph">This is a paragraph.</p>

The color of the text will be blue because the ID selector for "#paragraph" has a higher specificity than the element selector for "p".

If multiple selectors have the same specificity, the one that appears last in the CSS document takes precedence.

For example:

p {
  color: red;
}

#paragraph {
  color: blue;
}

p {
  font-size: 24px;
}

In this case, the color of the text will be blue and the font size will be 24px because the second "p" selector overrides the font size defined by the first "p" selector.

It's important to be aware of CSS specificity when writing stylesheets to ensure that the correct styles are applied to your HTML elements.

In general, it's best to use the least specific selectors possible to target elements, and to avoid using inline styles whenever possible.

7. CSS Responsive Queries

CSS responsive queries are used to create styles that adapt to different screen sizes and devices, allowing your web pages to look good on a variety of devices such as desktops, laptops, tablets, and smartphones.

There are several ways to create responsive designs using CSS, but the most common technique is using media queries.

Media queries allow you to define different styles for different screen sizes and resolutions.

Here's an example:

/* Styles for screens smaller than 768px */
@media (max-width: 767px) {
  .container {
    width: 100%;
    padding: 20px;
  }
  .heading {
    font-size: 24px;
  }
}

/* Styles for screens larger than 768px */
@media (min-width: 768px) {
  .container {
    width: 700px;
    margin: 0 auto;
    padding: 40px;
  }
  .heading {
    font-size: 36px;
  }
}

In this example, we have defined two media queries.

The first query targets screens smaller than 768px and applies styles to the "container" and "heading" elements to make them more readable on small screens.

The second query targets screens larger than 768px and applies different styles to the same elements to make them look better on larger screens.

Media queries can be based on a variety of factors such as screen size, resolution, device orientation, and more.

Here are some common media query options:

max-width:

Sets the maximum width of the screen.

min-width:

Sets the minimum width of the screen.

orientation:

Sets the device orientation to portrait or landscape.

max-device-width:

Sets the maximum width of the device screen.

min-device-width:

Sets the minimum width of the device screen.

By using media queries in your CSS, you can create responsive designs that look good on any device.

However, it's important to test your styles on a variety of devices to ensure that they work as expected.

8. Flexbox/Grid

Flexbox and CSS Grid are two popular CSS layout systems used to create responsive and flexible designs.

Here's a brief overview of each:

Flexbox:

Flexbox is a one-dimensional layout system that is designed to make it easier to create flexible and responsive layouts.

It allows you to align and distribute content within a container in a flexible way.

Flexbox works by creating a flexible container that can hold a set of flexible items.

You can define the size, order, and alignment of these items using various properties such as display, flex-direction, justify-content, align-items, and flex-wrap.

CSS Grid:

CSS Grid is a two-dimensional layout system that is designed to create complex grid layouts that are responsive and flexible.
It allows you to define rows and columns in a grid and place content in specific areas within the grid.

CSS Grid works by creating a container that is divided into a set of rows and columns.

You can define the size and position of these rows and columns using various properties such as grid-template-rows, grid-template-columns, grid-row-start, grid-column-end, and grid-gap.

Flexbox is best suited for creating one-dimensional layouts such as navigation menus, card layouts, and form layouts.

CSS Grid is best suited for creating complex two-dimensional layouts such as magazine-style layouts, image galleries, and dashboard layouts.

However, both Flexbox and CSS Grid can be used together to create more complex and flexible layouts.

Overall, Flexbox and CSS Grid are both powerful layout systems that can help you create responsive and flexible designs.

It's important to choose the right layout system based on your specific needs and to use them appropriately to achieve the desired layout.

9. Common header meta tags

Header meta tags are an important part of a web page's HTML code that provide information about the page's content to search engines, social media platforms, and other web services.

Here are some of the most common header meta tags and their purposes:

<meta charset="UTF-8">

Specifies the character encoding used by the page. UTF-8 is the most widely used character encoding and supports all Unicode characters.

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

Specifies the viewport settings for mobile devices, which affects the layout and scaling of the page on different devices.

This tag tells the browser to use the width of the device as the width of the viewport, and to set the initial zoom level to 1.

<title>Page Title</title>

Specifies the title of the page, which appears in the browser's title bar and is used by search engines as the title of the search result.

<meta name="description" content="Page description">

Specifies a brief description of the page's content, which appears in search results and is used by search engines to understand the page's content.

<meta name="keywords" content="keyword1, keyword2, keyword3">

Specifies a comma-separated list of keywords that describe the page's content, which can help search engines understand the page's topic and improve its ranking.

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

Specifies whether search engines should index the page and follow its links.

By default, search engines will index and follow all pages.

<link rel="canonical" href="https://www.example.com/">

Specifies the canonical URL of the page, which is the preferred URL that search engines should use to index the page.

This is useful when there are multiple URLs that can access the same content.

10. Open Graph Tags

Open Graph tags are meta tags that are used to provide social media platforms and search engines with information about a web page.

They are used to specify the title, description, and image to be used when a page is shared on social media or displayed in search results.

Here are some examples of Open Graph tags :

Title Tag:

The title tag specifies the title of the page, which is displayed in search results and on social media platforms.

Here's an example:

<head>
  <title>My Website Title</title>
  <meta property="og:title" content="My Website Title"/>
</head>

Description Tag:

The description tag provides a summary of the page's content and is displayed in search results and on social media platforms.

Here's an example:

<head>
  <meta name="description" content="A description of my website."/>
  <meta property="og:description" content="A description of my website."/>
</head>

Image Tag:

The image tag specifies the image to be displayed when the page is shared on social media platforms.

Here's an example:

<head>
  <meta property="og:image" content="https://example.com/image.jpg"/>
</head>

URL Tag:

The URL tag specifies the URL of the page, which is displayed in search results and on social media platforms.

Here's an example:

<head>
  <link rel="canonical" href="https://example.com"/>
  <meta property="og:url" content="https://example.com"/>
</head>

Note that these Open Graph tags are typically placed in the head section of the HTML document, but they can also be included in CSS files using the @import rule.

However, it's not recommended to include them in CSS files as it can cause problems with some social media platforms.

Conclusion

In conclusion, understanding the Box Model is essential to creating a well-structured webpage.

Inline and Block elements offer different styling options and should be chosen accordingly.

Positioning, both Relative and Absolute, are useful tools to create dynamic layouts.

CSS Specificity determines how styles are applied and should be used with caution.

CSS Responsive Queries allow websites to adapt to different screen sizes and devices.

Flexbox and Grid are powerful tools for creating complex layouts.

Lastly, using common header meta tags and Open Graph tags can enhance a website's social media presence and search engine visibility.

By utilizing these CSS techniques and best practices, you can create a visually appealing and engaging website that works across multiple platforms and devices.

References

Box Model:

https://www.w3schools.com/css/css_boxmodel.asp

Inline versus Block Elements:

https://css-tricks.com/when-do-you-use-inline-block/

Positioning: Relative/Absolute:

https://developer.mozilla.org/en-US/docs/Web/CSS/position

Common CSS Structural Classes:

https://developer.mozilla.org/en-US/docs/Web/CSS/container

Common CSS Styling Classes:

https://css-tricks.com/almanac/

CSS Specificity:

https://specificity.keegan.st/

CSS Responsive Queries:

https://www.w3schools.com/css/css_rwd_mediaqueries.asp

Flexbox/Grid:

https://css-tricks.com/snippets/css/a-guide-to-flexbox/
https://css-tricks.com/snippets/css/complete-guide-grid/

Common Header Meta Tags:

https://www.w3schools.com/tags/tag_head.asp

Open Graph Tags:

https://ogp.me/

SQL Concepts

Manisha Kundrapu — Tue, 21 Feb 2023 06:58:58 +0000

The following are some of the concepts that are included to understand databases:

ACID
CAP Theorem
Joins
Aggregations and Filters in Queries
Normalization
Indexes
Transactions
Locking Mechanism
Database Isolation Levels
Triggers

ACID

ACID is an acronym that stands for Atomicity, Consistency, Isolation, and Durability.

These are the key properties of a database transaction that ensure data integrity and reliability.

1. Atomicity:

Atomicity guarantees that a transaction is treated as a single, indivisible unit of work that either completes in its entirety or is rolled back (undone) completely in the event of any failure or error.

Example:

A bank transfer that involves deducting money from one account and adding it to another account is an example of an atomic transaction. If either the debit or credit transaction fails, both transactions should be rolled back to ensure data consistency.

2. Consistency:

Consistency ensures that a transaction takes the database from one valid state to another valid state. It ensures that the database is consistent both before and after the transaction.

Example:

If a transaction involves adding a new record to a database, it should ensure that the record meets all the constraints and rules set forth by the database schema before being added.

3. Isolation:

Isolation ensures that each transaction is executed independently of any other transaction, without interference or dependence on any other transaction occurring simultaneously.

Example:

If two transactions occur simultaneously, one transaction should not be able to access the data modified by another transaction until the transaction is completed and the data is committed to the database.

4. Durability:

Durability ensures that once a transaction is committed to the database, it will remain there permanently, even in the event of power failures, crashes, or other system failures.

Example:

If a database crashes after a transaction has been committed, the data from that transaction will still be available when the database is restored.

Overall, ACID provides a set of principles to ensure that database transactions are reliable, consistent, and accurate, making it an essential concept for building robust and scalable database systems.

CAP Theorem

The CAP theorem, also known as Brewer's theorem, is a fundamental concept in distributed database systems that describes the tradeoffs that must be made when building highly available and fault-tolerant systems.

The theorem states that in a distributed database system, you can only have two out of the following three guarantees.

1. Consistency:

All nodes in the system see the same data at the same time, regardless of which node receives the update request.

2. Availability:

Every request made to the system receives a response, without guarantee that it contains the most recent version of the information.

3. Partition tolerance:

The system continues to operate despite arbitrary message loss or failure of part of the system.

In practical terms, this means that when building a distributed database system, you must choose which two of these guarantees are most important for your application and optimize the system accordingly.

For example, consider an e-commerce website that relies on a distributed database to manage inventory and process transactions. In this scenario, consistency and availability are the two most important guarantees, as it is critical that the website always has accurate inventory information and can process transactions in a timely manner. Partition tolerance may be less important, as the website can temporarily go offline if there is a network issue or a node failure.

On the other hand, consider a social media platform where users are frequently posting updates, and the priority is to ensure that all updates are eventually replicated across all nodes in the system, even in the event of network partitions. In this scenario, partition tolerance and consistency are the two most important guarantees, while availability may be less critical.

Overall, the CAP theorem highlights the fundamental tradeoffs that must be made when building distributed database systems, and emphasizes the importance of choosing the appropriate tradeoffs based on the requirements of your specific application.

Joins

In SQL, a join is a way to combine data from two or more tables into a single result set based on a common column. There are several types of joins, including:

1. Inner join:

Returns only the rows that have matching values in both tables.

Example:

Suppose you have two tables - "orders" and "customers". To get a list of all orders along with the customer name, you can use an inner join on the "customer_id" column.

SELECT orders.order_id, customers.customer_name
FROM orders
INNER JOIN customers
ON orders.customer_id = customers.customer_id;

2. Left join:

Returns all rows from the left table and matching rows from the right table. If there are no matching rows in the right table, the result will contain NULL values for the right table columns.

Example:

Suppose you have two tables - "customers" and "orders". To get a list of all customers and their orders (if any), you can use a left join on the "customer_id" column.

SELECT customers.customer_name, orders.order_id
FROM customers
LEFT JOIN orders
ON customers.customer_id = orders.customer_id;

3. Right join:

Returns all rows from the right table and matching rows from the left table. If there are no matching rows in the left table, the result will contain NULL values for the left table columns.

Example:

Suppose you have two tables - "orders" and "customers". To get a list of all orders and the customer name (if available), you can use a right join on the "customer_id" column.

SELECT orders.order_id, customers.customer_name
FROM orders
RIGHT JOIN customers
ON orders.customer_id = customers.customer_id;

4. Full outer join:

Returns all rows from both tables, with NULL values in the columns where there are no matches.

Example:

Suppose you have two tables - "customers" and "orders". To get a list of all customers and all orders, you can use a full outer join on the "customer_id" column.

SELECT customers.customer_name, orders.order_id
FROM customers
FULL OUTER JOIN orders
ON customers.customer_id = orders.customer_id;

Joins are a powerful tool for combining data from multiple tables in SQL, and can be used in a variety of scenarios to retrieve useful information from a database.

Aggregations, Filters in queries

In SQL, aggregations and filters are powerful tools for querying and summarizing large datasets.

Aggregations are used to calculate summary statistics, such as averages, sums, counts, and maximum or minimum values, on one or more columns of data. The most commonly used aggregation functions in SQL include:

1. COUNT:

Returns the number of rows in a table or the number of rows that match a specified condition.

Example:

To count the number of orders in a table called "orders", you can use the following query:

SELECT COUNT(*)
FROM orders;

2. SUM:

Returns the sum of the values in a specified column.

Example:

To calculate the total revenue from a table called "sales", you can use the following query:

SELECT SUM(revenue)
FROM sales;

3. AVG:

Returns the average value of the values in a specified column.

Example:

To calculate the average price of a product from a table called "products", you can use the following query:

SELECT AVG(price)
FROM products;

Filters, on the other hand, are used to retrieve specific subsets of data from a table based on specified conditions.

The most commonly used filter clauses in SQL include:

1. WHERE:

Filters the data based on a specified condition.

Example:

To retrieve all orders with a total value greater than $1000 from a table called "orders", you can use the following query.

SELECT *
FROM orders
WHERE total_value > 1000;

2. GROUP BY:

Groups the data based on one or more columns, and allows for aggregations to be calculated for each group.

Example:

To calculate the total revenue for each region from a table called "sales", you can use the following query:

SELECT region, SUM(revenue)
FROM sales
GROUP BY region;

3. HAVING:

Filters the results of a GROUP BY clause based on a specified condition.

Example:

To retrieve all regions with a total revenue greater than $100,000 from a table called "sales", you can use the following query.

SELECT region, SUM(revenue)
FROM sales
GROUP BY region
HAVING SUM(revenue) > 100000;

Aggregations and filters are two essential tools for working with large datasets in SQL, and can be used together to generate powerful insights and reports.

Normalization

Normalization is a process of organizing data in a database to reduce redundancy and improve data integrity.

It involves breaking down a table into smaller tables and establishing relationships between them to eliminate data duplication and inconsistencies.

There are different levels of normalization, also known as normal forms.

The most commonly used are:

1. First Normal Form (1NF):

A table is in 1NF if it has no repeating groups or arrays. Each column in the table must contain atomic (indivisible) values.

For example, a table with a column for phone numbers should not store multiple phone numbers in a single field separated by commas.

2. Second Normal Form (2NF):

A table is in 2NF if it is in 1NF and all non-key columns are dependent on the entire primary key. In other words, all columns in a table must be related to the primary key, and not just a part of it.

For example, a table with customer orders should have separate tables for customers and orders, with the order table referencing the customer table through a foreign key.

3. Third Normal Form (3NF):

A table is in 3NF if it is in 2NF and has no transitive dependencies. In other words, all non-key columns in a table must be related only to the primary key, and not to other non-key columns.

For example, a table with information about customers and their orders should not have a column for the salesperson who made the sale, as this information is not directly related to the customer or the order.

Example:

Consider a table called "Customer_Order" with the following columns.

Customer_ID
Customer_Name
Customer_Phone
Order_ID
Order_Date
Order_Amount

This table is not normalized as it contains repeating groups (phone numbers) and has transitive dependencies (order amount is dependent on order ID and not directly on customer ID). To normalize this table, we can create two separate tables as follows.

Customer table:

Customer_ID (Primary Key)
Customer_Name
Customer_Phone
Order table:

Order_ID (Primary Key)
Order_Date
Order_Amount
Customer_ID (Foreign Key)

By breaking down the original table into two smaller tables, we have eliminated redundancy and established a relationship between the customer and order tables through the customer ID and order ID columns.

This ensures data consistency and reduces the likelihood of errors in the database.

Indexes

Indexes in SQL are used to improve the performance of queries by allowing faster data retrieval.

An index is a data structure that contains a copy of selected columns of a table arranged in a specific order that enables faster lookups, sorting, and filtering.

When a query is executed, the database engine uses the index to locate the data more quickly, rather than scanning the entire table.

Indexes are typically created on columns that are frequently used in queries, such as primary keys or columns used in WHERE clauses.

There are several types of indexes available in SQL, including:

1. Clustered index:

A clustered index determines the physical order of the rows in a table based on the values in one or more columns. Each table can have only one clustered index.

2. Non-clustered index:

A non-clustered index creates a separate data structure that contains the index key values and a pointer to the location of the actual data. Multiple non-clustered indexes can be created on a table.

3. Unique index:

A unique index ensures that the values in a column or combination of columns are unique. Each table can have multiple unique indexes.

Example:

Consider a table called "Employee" with the following columns.

Employee_ID (Primary Key)
Employee_Name
Employee_Age
Employee_Salary

To improve the performance of queries that frequently use the Employee_Name column, we can create a non-clustered index on that column as follows.

CREATE NONCLUSTERED INDEX ix_Employee_Name ON Employee (Employee_Name)

This index creates a separate data structure containing the Employee_Name column and a pointer to the location of the actual data in the Employee table. When a query includes the Employee_Name column in a WHERE clause, the database engine can use the index to quickly locate the relevant rows in the table.

In addition, we can create a unique index on the Employee_ID column to ensure that each employee has a unique identifier:

CREATE UNIQUE INDEX ix_Employee_ID ON Employee (Employee_ID)

This index prevents duplicate values in the Employee_ID column, ensuring data integrity and efficient data retrieval for queries that use the Employee_ID column.

Transactions

In SQL, a transaction is a sequence of database operations that are executed as a single unit of work.

A transaction ensures that all the operations within it are completed successfully, or none of them are, so that the database remains in a consistent state.

Transactions typically include multiple SQL statements, such as SELECT, INSERT, UPDATE, and DELETE, and they are used to ensure data integrity and consistency.

If any part of a transaction fails, the database will automatically roll back all the changes made during the transaction to ensure that the database remains consistent.

To ensure that a sequence of SQL statements is executed as a transaction, we use the following commands:

BEGIN TRANSACTION: Starts a new transaction.
COMMIT: Ends a transaction and saves all the changes made during it.
ROLLBACK: Ends a transaction and undoes all the changes made during it.

Example:

Consider a table called "Bank_Account" with the following columns:

Account_ID (Primary Key)
Account_Balance

To transfer funds from one account to another, we can use a transaction to ensure that the transfer is completed successfully, or none of it is. The transaction can be implemented using the following SQL statements.

BEGIN TRANSACTION
UPDATE Bank_Account SET Account_Balance = Account_Balance - 500 WHERE Account_ID = 12345
UPDATE Bank_Account SET Account_Balance = Account_Balance + 500 WHERE Account_ID = 67890
COMMIT

In this example, the transaction begins with the BEGIN TRANSACTION statement. The two UPDATE statements transfer $500 from the account with the ID 12345 to the account with the ID 67890. Finally, the COMMIT statement ends the transaction and saves the changes made to the database.

If any part of the transaction fails, such as if there are insufficient funds in the account with the ID 12345, the ROLLBACK statement can be used to undo all the changes made during the transaction and ensure that the database remains in a consistent state.

Locking mechanism

In SQL, a locking mechanism is used to control access to data in a database and ensure that multiple transactions can work with the same data without causing conflicts.

Locking can prevent data inconsistencies and ensure data integrity by preventing multiple transactions from accessing the same data at the same time.

There are several types of locks available in SQL, including:

1. Shared lock:

Allows multiple transactions to read the same data at the same time, but prevents any transaction from modifying the data.

2. Exclusive lock:

Prevents any other transaction from accessing or modifying the data while the lock is held.

3. Update lock:

Allows multiple transactions to read the same data, but only one transaction can update the data at a time.

4. Intent lock:

Indicates that a transaction intends to acquire a lock on a particular resource, such as a row or a page.

5. Schema lock:

Prevents any other transaction from modifying the schema of a database object while the lock is held.

Example:
Consider a table called "Inventory" with the following columns:

Item_ID (Primary Key)
Item_Name
Item_Quantity

To prevent two transactions from updating the same item quantity at the same time, we can use a locking mechanism.

The following example shows how to use a shared lock to allow multiple transactions to read the same data, but prevent any transaction from modifying the data:

Transaction 1:

BEGIN TRANSACTION
SELECT Item_Quantity FROM Inventory WITH (UPDLOCK) WHERE Item_ID = 12345
-- Process the data
COMMIT

Transaction 2:

BEGIN TRANSACTION
SELECT Item_Quantity FROM Inventory WITH (UPDLOCK) WHERE Item_ID = 12345
-- Process the data
COMMIT

In this example, both transactions acquire an update lock on the row with the Item_ID 12345 using the WITH (UPDLOCK) clause in the SELECT statement. This prevents any other transaction from acquiring an exclusive lock on the same row while the update lock is held, ensuring that only one transaction can modify the data at a time.

Note that the shared lock acquired by the transactions allows other transactions to read the same data, but not modify it. If a transaction needs to modify the data, it must acquire an exclusive lock on the row, which prevents any other transaction from accessing the data until the lock is released.

Database Isolation Levels

In SQL, database isolation levels define how transactions interact with each other and with the data in the database.

Isolation levels determine the level of concurrency that is allowed in a database system, which can affect the consistency and accuracy of the data.

There are four commonly used isolation levels in SQL:

1. Read Uncommitted:

The lowest level of isolation, which allows transactions to read data that has been modified by other transactions, but not yet committed.

2. Read Committed:

This level of isolation allows transactions to read only committed data, which prevents dirty reads.

However, it still allows non-repeatable reads, where a transaction reads the same data twice and gets different results because another transaction has modified the data in between.

3. Repeatable Read:

This level of isolation ensures that a transaction can read the same data multiple times and get the same result, even if another transaction modifies the data in between.

This level prevents non-repeatable reads, but still allows phantom reads, where a transaction reads a set of rows and another transaction inserts new rows that match the same criteria.

4. Serializable:

The highest level of isolation, which provides the strongest level of consistency.

It ensures that transactions are executed as if they were executed sequentially, which prevents dirty reads, non-repeatable reads, and phantom reads.

However, this level of isolation can lead to a high level of contention, which can affect the performance of the database system.

Example:

Consider a table called "Order_Details" with the following columns:

Order_ID (Primary Key)
Product_Name
Quantity

To demonstrate the different isolation levels, we can use the following example:

Transaction 1:

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
BEGIN TRANSACTION
SELECT SUM(Quantity) FROM Order_Details WHERE Product_Name = 'Product A'
-- Process the data
COMMIT

Transaction 2:

SET TRANSACTION ISOLATION LEVEL READ COMMITTED
BEGIN TRANSACTION
SELECT SUM(Quantity) FROM Order_Details WHERE Product_Name = 'Product A'
-- Process the data
COMMIT

Transaction 3:

SET TRANSACTION ISOLATION LEVEL REPEATABLE READ
BEGIN TRANSACTION
SELECT SUM(Quantity) FROM Order_Details WHERE Product_Name = 'Product A'
-- Process the data
COMMIT

Transaction 4:

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
BEGIN TRANSACTION
SELECT SUM(Quantity) FROM Order_Details WHERE Product_Name = 'Product A'
-- Process the data
COMMIT

In this example, each transaction sets a different isolation level and retrieves the sum of the quantity for the product with the name "Product A" from the "Order_Details" table.

The different isolation levels affect how the transactions interact with each other and with the data in the database, which can lead to different results and different levels of consistency.

For example, the READ UNCOMMITTED level allows dirty reads, which means that Transaction 1 can read data that has been modified but not yet committed by other transactions.

On the other hand, the SERIALIZABLE level ensures the highest level of consistency by preventing dirty reads, non-repeatable reads, and phantom reads, but it can also lead to a high level of contention and reduced performance.

Triggers

In SQL, a trigger is a special type of stored procedure that is automatically executed in response to certain events or actions in a database.

Triggers can be used to enforce business rules, maintain data integrity, and automate certain database operations.

There are two types of triggers in SQL:

1. DML Triggers:

These triggers are fired in response to data manipulation language (DML) events, such as INSERT, UPDATE, and DELETE statements.

2. DDL Triggers:

These triggers are fired in response to data definition language (DDL) events, such as CREATE, ALTER, and DROP statements.

Triggers can be defined to execute either before or after the triggering event. A trigger can be defined to execute once for each statement, or once for each row that is affected by the statement.

Example:

Consider a table called "Employee" with the following columns:

Employee_ID (Primary Key)
Employee_Name
Salary

To demonstrate the use of triggers, we can create a trigger that automatically updates the "Salary" column of the "Employee" table whenever a new record is inserted into the table. The trigger will double the value of the "Salary" column for each new record.

CREATE TRIGGER trg_employee_insert
ON Employee
FOR INSERT
AS
BEGIN
UPDATE Employee SET Salary = Salary * 2 WHERE Employee_ID IN (SELECT Employee_ID FROM inserted)
END

In this example, the trigger is defined to execute after an insert statement is executed on the "Employee" table. The trigger updates the "Salary" column of the newly inserted record by multiplying it by 2. The "inserted" table is a special table that is available within a trigger and contains the rows that were inserted or modified by the triggering statement.

Now, if we insert a new record into the "Employee" table with the following statement:

INSERT INTO Employee (Employee_Name, Salary) VALUES ('John', 50000)

The trigger will automatically update the "Salary" column of the new record to 100000. Thus, the trigger has enforced a business rule that specifies that all new employees must have a salary that is double the original value.

Conclusion

In conclusion, with a solid understanding of these SQL concepts, users can design and manage databases that are efficient, reliable, and scalable.

References

ACID :
https://www.geeksforgeeks.org/acid-properties-in-dbms/

CAP Theorem :
https://www.geeksforgeeks.org/the-cap-theorem-in-dbms/

Joins :
https://www.geeksforgeeks.org/sql-join-set-1-inner-left-right-and-full-joins/

Aggregations, Filters in queries : https://www.geeksforgeeks.org/aggregate-functions-in-sql/

Normalization :
https://www.geeksforgeeks.org/normalization-process-in-dbms/

Indexes :
https://www.geeksforgeeks.org/sql-queries-on-clustered-and-non-clustered-indexes/

Transactions :
https://www.geeksforgeeks.org/sql-transactions/

Locking mechanism :
https://www.geeksforgeeks.org/difference-between-shared-lock-and-exclusive-lock/

Database Isolation Levels:
https://www.geeksforgeeks.org/transaction-isolation-levels-dbms/

Triggers :
https://www.javatpoint.com/triggers-in-sql-server

SOLID PRINCIPLES

Manisha Kundrapu — Mon, 20 Feb 2023 04:44:24 +0000

Object-Oriented Design is essential in software development when it comes to writing code that is flexible, scalable, maintainable, and reusable.

There are numerous advantages to using OOD, but every developer should understand the SOLID principle in order to create good object-oriented design in programming.

Robert C. Martin, also known as Uncle Bob, introduced the SOLID principle, which is now a programming coding standard.

The SOLID principle aids in lowering tight coupling.

Tight coupling in code should be avoided because it means a collection of classes are heavily dependent on one another.

Therefore when your classes are loosely coupled, your code is deemed to be of high quality.

Your code will be less likely to change due to the presence of loosely connected classes, which makes the code to be more reusable, maintainable, versatile, and stable.

This principle is an abbreviated version of the five principles listed below.

S - Single-responsiblity Principle
O - Open-closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

Single-Responsibility Principle (SRP):

According to this principle “a class should have only one reason to change” which means every class should have a single responsibility or single job or single purpose.

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

    def get_name(self) -> str:
        pass

    def save(self, Birds: Birds):
        pass

The aforementioned Birds class transgresses the SRP.

SRP stipulates that classes should only have one job; nevertheless, in this case, we may identify two , managing the Birds database and managing the Birds properties.

While the save controls how the Birds are stored in a database, the constructor and get name control how the properties of the Birds are managed.

If modifications to the program have an impact on how databases are managed, to account for the new modifications, the classes that utilise Birds attributes will need to be modified and recompiled.

We develop a different class that will be responsible for the sole task of maintaining Birds in a database in order to comply with SRP.

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

    def get_name(self):
        pass


class BirdsDB:
    def get_Birds(self) -> Birds:
        pass

    def save(self, Birds: Birds):
        pass

Open-Closed Principle (OCP) :

According to this principle "Objects or entities should be open for extension but closed for modification".

This means that without modifying the class behaviour , it needs to be extended.

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

    def get_name(self) -> str:
        pass

birds = [
    Birds('parrot'),
    Birds('crow')
]

def Birds_Colour(birds: list):
    for bird in birds:
        if bird.name == 'parrot':
            print('green')

        elif bird.name == 'crow':
            print('black')

Birds_Colour(birds)

The function Birds_Colour does not conform to the open-closed principle because it cannot be closed against new kinds of birds.

If we add a new bird, crane, We have to modify the Birds_Colour function.

You see, for every new bird, a new logic is added to the Birds_Colour function.

This is quite a simple example. When your application grows and becomes complex, you will see that the if statement would be repeated over and over again in the Birds_Colour function each time a new bird is added, all over the application.

birds = [
    Birds('parrot'),
    Birds('crow'),
    Birds('crane')
]

def Birds_Colour(birds: list):
    for bird in birds:
        if bird.name == 'parrot':
            print('green')
        elif bird.name == 'crow':
            print('black')
        elif bird.name == 'crane':
            print('white')

Birds_Colour(birds)

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

    def get_name(self) -> str:
        pass

    def Birds_Colour(self):
        pass


class parrot(Birds):
    def Birds_Colour(self):
        return 'green'


class crow(Birds):
    def Birds_Colour(self):
        return 'black'


class crane(Birds):
    def Birds_Colour(self):
        return 'white'


def Birds_Colour(Birds: list):
    for bird in birds:
        print(bird.Birds_Colour())

Birds_Colour(Birds)

Birds now has a virtual method Birds_Colour.

We have each bird extend the Birds class and implement the virtual Birds_Colour method.

Every bird adds its own implementation on its colour in the Birds_Colour.

The Birds_Colour iterates through the array of birds and just calls its Birds_Colour method.

Now, if we add a new bird, Birds_Colour doesn’t need to change.

All we need to do is add the new bird to the birds array.
Birds_Colour now conforms to the OCP principle.

Liskov’s Substitution Principle (LSP):

The principle was introduced by Barbara Liskov in 1987 and according to this principle “Derived or child classes must be substitutable for their base or parent classes“.

This principle ensures that any class that is the child of a parent class should be usable in place of its parent without any unexpected behavior.

For example we have a class called Amphibian for animals that can live on both land and water.

This class has two methods to show the features of an amphibian – swim() and walk().

class Amphibian(ABC):
    def swim() -> bool:
        print("Can Swim") 

    def walk() -> bool:
        print("Can Walk")

The Amphibian class can extend to a turtle class because turtles are amphibians, so they can inherit the properties of the Amphibian class without altering the logic and purpose of the class.

class turtle(Amphibian):
    def swim():
        return print("turtles can swim") 

    def walk():
        return print("turtles can walk")

But we cannot extend the Amphibian class to a shark class because shark only live in water which implies that the walk() method would be irrelevant to the shark class.

So, when you extend a class, if some of the properties of the initial class are not useful for the new class, the Liskov substitution principle has been violated.

The solution to this is simple, create interfaces that match the needs of the inheriting class.

class Swim(ABC):
    @abstractmethod
    def swim(self) -> bool:
        pass

class Walk(ABC):
    @abstractmethod
    def walk(self) -> bool:
        pass

class Amphibian(Swim, Walk):
    def swim(self) -> bool:
        print("Can Swim")
        return True

    def walk(self) -> bool:
        print("Can Walk")
        return True

class Turtle(Swim, Walk):
    def swim(self) -> bool:
        print("Turtles can swim")
        return True

    def walk(self) -> bool:
        print("Turtles can walk")
        return True

In this updated implementation, we define two interfaces, "Swim" and "Walk", which define the contract that any class implementing them must follow.

The "Amphibian" class implements both "Swim" and "Walk" interfaces, while the "Turtle" class also implements both interfaces.

By using interfaces, we ensure that any class implementing the "Swim" and "Walk" interfaces must have the same method signatures as defined in the interface, ensuring adherence to the Liskov Substitution Principle (LSP).

Interface Segregation Principle (ISP):

This principle is the first principle that applies to Interfaces instead of classes in SOLID and it is similar to the single responsibility principle.

It states that “do not force any client to implement an interface which is irrelevant to them“.

Here your main goal is to focus on avoiding fat interface and give preference to many small client-specific interfaces.

You should prefer many client interfaces rather than one general interface and each interface should have a specific responsibility.

In summary, if a class inherits another, it should do so in a manner that all the properties of the inherited class would remain relevant to its functionality.

class Walker(ABC):
  def walk() -> bool:
    return print("Can Walk") 

class Swimmer(ABC):
  def swim() -> bool:
    return print("Can Swim") 

class turtle(Walker, Swimmer):
  def walk():
    return print("turtles can walk") 
  def swim():
    return print("turtles can swim")

To run the above code we need to run


class Whale(Swimmer):
  def swim():
    return print("Whales can swim") 

if __name__ == "__main__":
  turtle.walk()
  turtle.swim()

  Whale.swim()

Dependency Inversion Principle (DIP):

According to this principle "Entities must depend on abstractions, not on concretions. It states that the high-level module must not depend on the low-level module, but they should depend on abstractions".

Consider the below example, where the DIP has been violated where , switch is a concept that is logically in a layer above the light bulb, and the switch relies on it.

This will lead to poor extensibility or even circular imports that prevent the program from being interpreted or compiled.

class LightBulb:

  def __init__(self, initial_state: bool=False):
    self.power = initial_state

  def turn_on(self):
    self.power = True

  def turn_off(self):
    self.power = False

class Switch:

  def __init__(self, light_bulb: LightBulb, pressed: bool=False):
    self.light_bulb = light_bulb
    self.pressed = pressed

  def toggle(self):
    self.pressed = not self.pressed # Toggle
    if self.pressed:
      self.light_bulb.turn_on()
    else:
      self.light_bulb.turn_off()

Instead of the light bulb telling the switch how the bulb should be handled, the switch should tell the light bulb how to implement it. The naive approach would be to define an interface that tells the light bulb how it should behave to be used with a switch.

class Device(ABC):
  power: boolean

  def __init__(self, initial_state: bool=False):
    self.power = initial_state

  def turn_on(self):
    raise NotImplementedError

  def turn_off(self):
    raise NotImplementedError

class Switch:

  def __init__(self, device: Device, pressed: bool=False):
    self.device = device
    self.pressed = pressed

  def toggle(self):
    self.pressed = not self.pressed # Toggle
    if self.pressed:
      self.device.turn_on()
    else:
      self.device.turn_off()  

class LightBulb(Device):

  def turn_on(self):
    self.power = True

  def turn_off(self):
    self.power = False

The dependency has been inverted. Instead of the switch relying on the light bulb, the light bulb now relies on an interface in a higher module. Also, both rely on abstractions, as required by the DIP.

Last but not least, we also fulfilled the requirement "Abstractions should not depend upon details. Details should depend upon abstractions" - The details of how the device behaves rely on the abstraction (Device interface).

Conclusion

SOLID principles are a set of design principles that aim to make software designs more maintainable, scalable, and flexible. By adhering to these principles, developers can create software that is easier to modify, extend, and test, leading to fewer bugs and better performance. Incorporating SOLID principles into the development process helps to reduce the complexity of the codebase and make it easier to understand, resulting in high-quality, maintainable code that meets the needs of users and stakeholders alike.

References

The references used are linked below.

https://www.youtube.com/watch?v=TMuno5RZNeE

https://www.youtube.com/playlist?list=PL6n9fhu94yhXjG1w2blMXUzyDrZ_eyOme

https://www.digitalocean.com/community/conceptual_articles/s-o-l-i-d-the-first-five-principles-of-object-oriented-design

https://medium.com/mindorks/solid-principles-explained-with-examples-79d1ce114ace

https://blog.damavis.com/en/solid-principles-illustrated-in-simple-python-examples/

Objects and Object Oriented Programming in Python

Manisha Kundrapu — Thu, 16 Feb 2023 06:40:18 +0000

In Python, as well as in many other programming languages, object-oriented programming (OOP) is a popular programming paradigm.

OOP is a way of structuring code that allows us to represent real-world objects as software objects.

Classes and Objects:

An object is an instance of a class.

A class is a blueprint for creating objects, which defines the attributes and methods that the objects will have.

An attribute is a piece of data that an object has, while a method is a function that operates on the object's data.

Consider the below example,

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

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

In this example, we define a class called Person, which has two attributes, name and age, and one method, say_hello.

When a new instance of the class is created, a unique method named init is invoked.

The self parameter refers to the instance of the class that is being created, and it is used to set the values of the name and age attributes.

Consider the below example,

person1 = Person("Alice", 25)
In this example, we create a new object called person1 of the Person class, with the name "Alice" and age 25.

We can then call the say_hello method on the person1 object:

person1.say_hello()

This will output "Hello, my name is Alice and I am 25 years old."

OOP allows us to write more modular, reusable, and maintainable code.

We can define a class once and then create many instances of it, each with their own unique data. We can also create subclasses that inherit attributes and methods from a parent class, and add their own unique attributes and methods.

Polymorphism:

An object's capacity to assume different forms is known as polymorphism.

In Python, polymorphism is achieved through the use of method overriding and method overloading.

Method Overriding:

Method overriding is the ability of a subclass to override a method of its superclass.

Here is an example,

class Animal:
    def sound(self):
        print("Animal makes a sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

class Cat(Animal):
    def sound(self):
        print("Cat meows")

In this example, we define a class called Animal, which has a method called sound.

We then define two subclasses, Dog and Cat, which override the sound method to provide their own implementation.

Method Overloading:

Method overloading is the ability to define multiple methods with the same name, but with different parameters.

In Python, method overloading is achieved through the use of default arguments.

Here is an example,

class Math:
    def add(self, a, b, c=0):
        return a + b + c

m = Math()
print(m.add(1, 2)) # Output: 3
print(m.add(1, 2, 3)) # Output: 6

In this example, we define a class called Math, which has a method called add.

The add method takes two required parameters, a and b, and an optional parameter, c.

If the c parameter is not provided, it defaults to 0.

This allows us to call the add method with either two or three arguments.

Encapsulation:

Encapsulation is the concept of hiding the internal details of an object from the outside world, and only exposing a public interface.

This allows us to change the internal implementation of an object without affecting the rest of the program.

Encapsulation is accomplished in Python by using private properties and functions.

Private attributes and methods are indicated by a double underscore before their name.

Here is an example,

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds")

    def get_balance(self):
        return self.__balance

In this example, we define a class called BankAccount, which has a private attribute __balance.

The deposit and withdraw methods allow us to modify the __balance attribute, while the get_balance method allows us to access the __balance attribute.

By making the __balance attribute private, we prevent the outside world from directly modifying it.

Inheritance:

Inheritance is the concept of creating a new class that is a modified version of an existing class.

The term "superclass" refers to the current class, and "subclass" to the new class.

The subclass inherits all of the attributes and methods of the superclass, and can also have its own unique attributes and methods.

Example:

class parent_class:
    x = "Parent class variable"

class child_class(parent_class):
    pass

c1 = Test()
obj = child_class()
print(obj.x)

Output:

Parent class variable

Here we can observe that we have created the object of class child_class.

And we do not have any class members in our class child_class.

But we inherited the properties of class parent_class into class child_class.

The class variable in class parent_class is inherited from class child_class.

Hence it is called using the object of class child_class.

Python supports different types of inheritance, which are:

Single inheritance
Multiple inheritances
Multilevel inheritance
Hierarchical inheritance
Hybrid inheritance

1. Single inheritance:

This is the simplest type of inheritance, where a child class inherits from a single parent class.

For example:

class ParentClass:
    def parent_method(self):
        print("This is a parent method.")

class ChildClass(ParentClass):
    def child_method(self):
        print("This is a child method.")

child = ChildClass()
child.parent_method()   
child.child_method()

2. Multiple inheritances:

This type of inheritance allows a child class to inherit from multiple parent classes.

In Python, this is achieved by listing the parent classes in a comma-separated list in the parentheses.

For example:

class ParentClass1:
    def parent1_method(self):
        print("This is a parent 1 method.")

class ParentClass2:
    def parent2_method(self):
        print("This is a parent 2 method.")

class ChildClass(ParentClass1, ParentClass2):
    def child_method(self):
        print("This is a child method.")

child = ChildClass()
child.parent1_method()   
child.parent2_method()  
child.child_method()

3. Multi-level inheritance:

This type of inheritance involves creating a hierarchy of classes, where a child class inherits from a parent class, which in turn, inherits from another parent class.

For example:

class GrandParentClass:
    def grandparent_method(self):
        print("This is a grandparent method.")

class ParentClass(GrandParentClass):
    def parent_method(self):
        print("This is a parent method.")

class ChildClass(ParentClass):
    def child_method(self):
        print("This is a child method.")

child = ChildClass()
child.grandparent_method()  # This is a grandparent method.
child.parent_method()       # This is a parent method.
child.child_method()        # This is a child method.

4. Hierarchical inheritance:

when more than one child class is derived from or inherited from a single (same) parent class.

Then this type of inheritance is called hierarchical inheritance.

class ParentClass:
    def parent_method(self):
        print("This is a parent method.")

class ChildClass1(ParentClass):
    def child1_method(self):
        print("This is a child 1 method.")

class ChildClass2(ParentClass):
    def child2_method(self):
        print("This is a child 2 method.")

child1 = ChildClass1()
child1.parent_method()   # This is a parent method.
child1.child1_method()   # This is a child1 method.

child2 = ChildClass2()
child2.parent_method()   # This is a parent method.
child2.child2_method()   # This is a child2 method.

5. Hybrid inheritance:

This type of inheritance combines multiple types of inheritance, such as single, multiple, and multi-level inheritance, to create a more complex inheritance hierarchy.

class GrandParentClass:
    def grandparent_method(self):
        print("This is a grandparent method.")

class ParentClass1(GrandParentClass):
    def parent1_method(self):
        print("This is a parent 1 method.")

class ParentClass2:
    def parent2_method(self):
        print("This is a parent 2 method.")

class ChildClass(ParentClass1, ParentClass2):
    def child_method(self):
        print("This is a child method.")

child = ChildClass()
child.grandparent_method()  
child.parent1_method()     
child.parent2_method()      
child.child_method()

In the above example, ChildClass is inheriting from two parent classes, ParentClass1 and ParentClass2.

ParentClass1 itself inherits from GrandParentClass, creating a multi-level inheritance hierarchy.

Hybrid inheritance can become complex and difficult to understand, so it's important to use it judiciously and keep the hierarchy as simple and intuitive as possible.

Data Abstraction:

Data abstraction is a technique used in object-oriented programming to hide the complexity of the data and expose only the necessary information to the user.

It provides a simplified view of the data, making it easier to understand and work with.

In Python, data abstraction can be achieved using abstract classes and interfaces.

Here's an example of data abstraction using abstract classes:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

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

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

    def perimeter(self):
        return 2 * (self.length + self.width)

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

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

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

rect = Rectangle(5, 10)
print(rect.area())       # 50
print(rect.perimeter())  # 30

circ = Circle(7)
print(circ.area())       # 153.86
print(circ.perimeter())  # 43.96

In this example, Shape is an abstract class that defines the interface for calculating the area and perimeter of a shape.

Rectangle and Circle are concrete classes that implement the Shape interface.

By using abstract classes, we can create a simplified view of the shapes that hides the complexity of the calculations.

Another way to achieve data abstraction in Python is using interfaces, which are a collection of abstract methods that define a contract between a class and the outside world.

The abc module provides the ABC class, which can be used to define interfaces:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

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

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

dog = Dog()
print(dog.make_sound())  # Woof!

cat = Cat()
print(cat.make_sound())  # Meow!

In this example, Animal is an interface that defines the make_sound method.

Dog and Cat are concrete classes that implement the Animal interface by providing their own implementation of the make_sound method.

By using interfaces, we can create a simplified view of the animals that hides the complexity of their behavior.

In conclusion, if you want to write more modular, reusable, and maintainable code, object-oriented programming (OOP) in Python is a great choice. With OOP, you can represent real-world objects as software objects and write code that is easier to maintain, debug, and extend. By defining classes that encapsulate attributes and methods, you can create many instances of objects with unique data, and even create subclasses that inherit attributes and methods from a parent class. With these powerful concepts, you can build complex systems and solve real-world problems with ease. Whether you are a beginner or an experienced developer, mastering OOP in Python is a skill that will undoubtedly take your programming abilities to the next level.

References:

GeeksforGeeks - "Python OOPs Concepts." https://www.geeksforgeeks.org/python-oops-concepts/

Python String Methods

Manisha Kundrapu — Thu, 16 Feb 2023 04:17:03 +0000

Python provides a wide range of methods that can be applied on string objects.

Here are most of the string methods available in Python:

1. capitalize():

The capitalize() method converts the first character of a string to an uppercase letter and all other alphabets to lowercase.

Syntax : string.capitalize()

Example:

string = "hello world"
capitalized_string = string.capitalize()
print(capitalized_string)

Output:

Hello world

2. casefold():

The casefold() method converts all characters of the string into lowercase letters and returns a new string.

Syntax : str.casefold()

Example:

string = "HELLO WORLD"
casefolded_string = string.casefold()
print(casefolded_string)

Output:

hello world

3. center():

The center() method returns a new centered string after padding it with the specified character.

Syntax : str.center(width, [fillchar])

width - length of the string with padded characters
fillchar (optional) - padding character

Example:

string = "hello"
centered_string = string.center(10, "-")
print(centered_string)

Output:

--hello---

4. count():

This method returns the number of non-overlapping occurrences of a substring in the string. You can also specify the start and end positions to search within the string.

Syntax : string.count(substring, start=..., end=...)

substring - string whose count is to be found.
start (Optional) - starting index within the string where search starts.
end (Optional) - ending index within the string where search ends.

Example:

string = "hello world"
count = string.count("o")
print(count)

Output:

5. encode():

This method returns an encoded version of the string using the specified encoding.

Syntax : encode(encoding="utf-8", errors="strict")

By default, the encode() method doesn't require any parameters.

It returns an utf-8 encoded version of the string. In case of failure, it raises a UnicodeDecodeError exception.

However, it takes two parameters:

encoding : the encoding type a string has to be encoded to.
errors : response when encoding fails.

There are six types of error response.

strict - default response which raises a UnicodeDecodeError exception on failure.

ignore - ignores the unencodable unicode from the result.

replace - replaces the unencodable unicode to a question mark.

xmlcharrefreplace - inserts XML character reference instead of unencodable unicode.

backslashreplace - inserts a \uNNNN escape sequence instead of unencodable unicode.

namereplace - inserts a \N{...} escape sequence instead of unencodable unicode.

Example:

string = "hello world"
encoded_string = string.encode("utf-8")
print(encoded_string)

Output:

b'hello world'

6. endswith():

This method returns True if the string ends with the specified suffix. You can also specify the start and end positions to search within the string.

Syntax : endswith(suffix[, start[, end]])

Example:

string = "hello world"
ends_with = string.endswith("ld")
print(ends_with)

Output:

True

7. expandtabs():

The expandtabs() method returns a copy of string with all tab characters '\t' replaced with whitespace characters until the next multiple of tabsize parameter.

Syntax : string.expandtabs(tabsize)

The expandtabs() takes an integer tabsize argument. The default tabsize is 8.

Example:

string = "hello\tworld"
expanded_string = string.expandtabs(4)
print(expanded_string)

Output:

hello world

8. find():

This method returns the lowest index of the first occurrence of a substring in the string.
If the substring is not found, it returns -1.
You can also specify the start and end positions to search within the string.

Syntax : find(sub[, start[, end]])

sub - It is the substring to be searched in the str string.

start and end (optional) - The range str[start:end] within which substring is searched.

Example:

string = "hello world"
index = string.find("o")
print(index)

Output:

9. format() :

This method formats the string using the specified arguments.

Syntax : format(*args, **kwargs)

Example:

name = "Alice"
age = 30
formatted_string = "My name is {0} and I am {1} years old".format(name, age)
print(formatted_string)

Output:

My name is Alice and I am 30 years old

10. format_map():

This method formats the string using the specified mapping.

Syntax : str.format_map(mapping)

Example:

mapping = {"name": "Alice", "age": 30}
formatted_string = "My name is {name} and I am {age} years old".format_map(mapping)
print(formatted_string)

Output:

My name is Alice and I am 30 years old

11. index():

The index() method returns the index of the first occurrence of a substring in a string. If the substring is not found, it raises a ValueError.

Syntax : string.index(substring[, start[, end]])

Example:

string = "Hello World"
print(string.index("o")) # Output: 4
print(string.index("ld")) # Output: 9

12. isalnum():

The isalnum() method returns True if all the characters in the string are alphanumeric (letters or numbers), and there is at least one character. Otherwise, it returns False.

Syntax : string.isalnum()

Example:

string = "Hello123"
print(string.isalnum()) # Output: True

string = "Hello123@"
print(string.isalnum()) # Output: False

13. isalpha():

The isalpha() method returns True if all the characters in the string are alphabets (letters), and there is at least one character. Otherwise, it returns False.

Syntax : string.isalpha()

Example:

string = "Hello"
print(string.isalpha()) # Output: True

string = "Hello123"
print(string.isalpha()) # Output: False

14. isdecimal():

The isdecimal() method returns True if all the characters in the string are decimal (numbers), and there is at least one character. Otherwise, it returns False.

Syntax : string.isdecimal()

Example:

string = "12345"
print(string.isdecimal()) # Output: True

string = "12345abc"
print(string.isdecimal()) # Output: False

15. isdigit():

The isdigit() method returns True if all the characters in the string are digits (0-9), and there is at least one character. Otherwise, it returns False.

Syntax : string.isdigit()

Example:

string = "12345"
print(string.isdigit()) # Output: True

string = "12345abc"
print(string.isdigit()) # Output: False

16. isidentifier():

The isidentifier() method returns True if the string is a valid Python identifier. A valid identifier is a sequence of letters, digits, or underscore characters that starts with a letter or an underscore.

Syntax : string.isidentifier()

Example:

string = "my_variable"
print(string.isidentifier()) # Output: True

string = "123variable"
print(string.isidentifier()) # Output: False

17. islower():

The islower() method returns True if all the alphabetic characters in the string are lowercase. Otherwise, it returns False.

Syntax : string.islower()

Example:

string = "hello world"
print(string.islower()) # Output: True

string = "Hello World"
print(string.islower()) # Output: False

18. isnumeric():

The isnumeric() method returns True if all the characters in the string are numeric characters. Otherwise, it returns False.

Syntax : string.isnumeric()

Example:

string = "123"
print(string.isnumeric()) # Output: True

string = "123abc"
print(string.isnumeric()) # Output: False

19. isprintable():

The isprintable() method returns True if all the characters in the string are printable or the string is empty. Otherwise, it returns False. A character is considered printable if it is not a control character.

Syntax : string.isprintable()

Example:

string = "Hello World!"
print(string.isprintable()) # Output: True

string = "\nHello World!"
print(string.isprintable()) # Output: False

20. isspace():

The isspace() method returns True if all the characters in the string are whitespace characters. Otherwise, it returns False. A whitespace character is a space, tab, newline, or any other character that is considered a space.

Syntax : string.isspace()

Example:

string = "   \t\n"
print(string.isspace()) # Output: True

string = " Hello World "
print(string.isspace()) # Output: False

21. istitle():

The istitle() method returns True if the string is a titlecased string, i.e., the first character of each word in the string is in uppercase and all other characters are in lowercase. Otherwise, it returns False.

Syntax : string.istitle()

Example:

string = "Hello World"
print(string.istitle()) # Output: False

string = "Hello, World!"
print(string.istitle()) # Output: True

22. isupper():

The isupper() method returns True if all the alphabetic characters in the string are uppercase. Otherwise, it returns False.

Syntax: string.isupper()

Example:

string = "HELLO WORLD"
print(string.isupper()) # Output: True

string = "Hello World"
print(string.isupper()) # Output: False

23. join():

The join() method concatenates a list of strings using the specified string as the separator. It returns a new string that is the concatenation of all the strings in the list, separated by the specified string.

Syntax : separator.join(iterable)

Example:

words = ["Hello", "World"]
separator = ", "
print(separator.join(words)) # Output: "Hello, World"

words = ["1", "2", "3"]
separator = "-"
print(separator.join(words)) # Output: "1-2-3"

24. ljust():

The ljust() method returns a left-justified version of the string. It pads the original string with a specified character (by default, a space character) on the right side until the resulting string reaches the specified length.

Syntax : string.ljust(width[, fillchar])

Example:

string = "Hello"
print(string.ljust(10)) # Output: "Hello     "

string = "Hello"
print(string.ljust(10, "-")) # Output: "Hello-----"

25. lower():

The lower() method returns a new string with all the alphabetic characters in the original string converted to lowercase.

Syntax : string.lower()

Example:

string = "Hello World"
print(string.lower()) # Output: "hello world"

string = "123"
print(string.lower()) # Output: "123"

26. lstrip():

The lstrip() method returns a new string with all leading whitespace characters removed. By default, it removes all whitespace characters, but you can also specify a specific set of characters to remove.

Syntax : string.lstrip([chars])

Example:

string = "  Hello World  "
print(string.lstrip()) # Output: "Hello World  "

string = "====Hello World==="
print(string.lstrip("=")) # Output: "Hello World==="

27. maketrans():

The maketrans() method creates a translation table that can be used with the translate() method to replace characters in a string.

Syntax : str.maketrans(x[, y[, z]])

Example:

intab = "aeiou"
outtab = "12345"
translation_table = str.maketrans(intab, outtab)
string = "Hello World"
print(string.translate(translation_table))

Output:

"H2ll4 W4rld"

28. partition():

The partition() method separates a string into three parts based on the first occurrence of a specified separator. It returns a tuple containing the left part of the string, the separator itself, and the right part of the string.

Syntax : string.partition(separator)

Example:

string = "Hello, World!"
print(string.partition(","))

Output:

("Hello", ",", " World!")

29. replace():

The replace() method returns a new string with all occurrences of a specified substring replaced with another substring.

Syntax : string.replace(old, new[, count])

Example:

string = "Hello, World!"
print(string.replace(",", "-"))

Output: "Hello- World!"

string = "Hello, World!"
print(string.replace(",", "-", 1))

Output: "Hello- World!"

30. rfind():

The rfind() method searches a string for a specified substring starting from the end of the string and returns the index of the last occurrence of the substring. If the substring is not found, it returns -1.

Syntax : string.rfind(sub[, start[, end]])

Example :

string = "Hello, World!"
print(string.rfind("l")) # Output: 10

string = "Hello, World!"
print(string.rfind("x")) # Output: -1

31. rindex():

The rindex() method is similar to the index() method, but it searches for a substring starting from the end of the string instead of the beginning. It raises a ValueError if the substring is not found.

Syntax : string.rindex(sub[, start[, end]])

Example:

string = "Hello, World!"
print(string.rindex("o")) # Output: 8

string = "Hello, World!"
print(string.rindex("x"))

Output:

ValueError: substring not found

32. rjust():

The rjust() method returns a right-justified version of the string. It pads the original string with a specified character (by default, a space character) on the left side until the resulting string reaches the specified length.

Syntax : string.rjust(width[, fillchar])

Example:

string = "Hello"
print(string.rjust(10)) # Output: "     Hello"

string = "Hello"
print(string.rjust(10, "-")) # Output: "-----Hello"

33. rpartition():

The rpartition() method is similar to the partition() method, but it searches for a separator starting from the end of the string instead of the beginning.

Syntax : string.rpartition(separator)

Example:

string = "Hello, World!"
print(string.rpartition(","))

Output:

("Hello, World", ",", "")

34. rsplit():

The rsplit() method is similar to the split() method, but it splits the string from the right end instead of the left. You can also specify the maximum number of splits to perform.

Syntax: string.rsplit([sep[, maxsplit]])

Example:

string = "Hello World, How are you?"
print(string.rsplit(",", 1))

Output:

["Hello World", " How are you?"]

35. rstrip():

The rstrip() method returns a new string with all trailing whitespace characters removed. By default, it removes all whitespace characters, but you can also specify a specific set of characters to remove.

Syntax : string.rstrip([chars])

Example:

string = "  Hello World  "
print(string.rstrip()) # Output: "  Hello World"

string = "====Hello World==="
print(string.rstrip("=")) # Output: "====Hello World"

36. split():

The split() method splits a string into a list of substrings based on a specified separator. By default, it splits the string on whitespace characters, but you can also specify a different separator.

Syntax : string.split([sep[, maxsplit]])

Example:

string = "Hello World, How are you?"
print(string.split())

Output: ["Hello", "World,", "How", "are", "you?"]

string = "Hello-World-How-are-you?"
print(string.split("-"))

Output: ["Hello", "World", "How", "are", "you?"]

37. splitlines():

The splitlines() method splits a string into a list of substrings based on newline characters. It works on both Windows and Unix-style newline characters.

Syntax : string.splitlines([keepends])

Example:

string = "Hello\nWorld\nHow\nare\nyou?"
print(string.splitlines())

Output:

["Hello", "World", "How", "are", "you?"]

38. startswith():

The startswith() method returns True if a string starts with a specified substring; otherwise, it returns False.

Syntax : string.startswith(substring[, start[, end]])

Example:

string = "Hello, World!"
print(string.startswith("Hello")) # Output: True

string = "Hello, World!"
print(string.startswith("World", 7)) # Output: True

39. strip():

The strip() method returns a new string with all leading and trailing whitespace characters removed. By default, it removes all whitespace characters, but you can also specify a specific set of characters to remove.

Syntax : string.strip([chars])

Example:

string = "  Hello World  "
print(string.strip()) # Output: "Hello World"

string = "====Hello World==="
print(string.strip("=")) # Output: "Hello World"

40. swapcase():

The swapcase() method returns a new string with all uppercase characters converted to lowercase and all lowercase characters converted to uppercase.

Syntax : string.swapcase()

Example:

string = "Hello, World!"
print(string.swapcase())

Output:

"hELLO, wORLD!"

41. title():

The title() method returns a new string with the first character of each word in the string capitalized and the remaining characters in lowercase.

Syntax : string.title()

Example:

string = "hello world"
print(string.title())

Output:

"Hello World"

42. translate():

The translate() method returns a new string where some specified characters are replaced with the character described in a dictionary, or in a mapping table.

Syntax : string.translate(table)

Example:

string = "Hello, World!"
translation_table = str.maketrans("o", "e")
print(string.translate(translation_table))

Output:

"Helle, Werld!"

43. upper():

The upper() method returns a new string with all the characters in uppercase.

Syntax : string.upper()

Example:

string = "Hello, World!"
print(string.upper())

Output:

"HELLO, WORLD!"

44. zfill():

The zfill() method pads a numeric string with zeros on the left side to fill a specified width. It does not modify the original string.

Syntax : string.zfill(width)

Example:

string = "42"
print(string.zfill(5)) # Output: "00042"

string = "-42"
print(string.zfill(5)) # Output: "-0042"

Python Array Methods

Manisha Kundrapu — Thu, 16 Feb 2023 01:30:22 +0000

In Python, an array is a container that holds a fixed number of items of the same type.

Arrays are useful for working with large amounts of data that need to be accessed quickly.

Python provides a built-in module called "array" for working with arrays.

Here are some commonly used methods for working with arrays in Python:

1. Creating an array:

To create an array in Python, you first need to import the "array" module.

Then, you can create an array using the "array" function and passing it a type code and a sequence of values.

‘b’ – signed char

‘B’ – unsigned char

‘d’ – double

‘f’ – float

‘i’ – signed int

‘I’ – unsigned int

‘h’ – signed short

‘H’ – unsigned short

‘l’ – signed long

‘L’ – unsigned long

Example:

import array
ar = array.array('i', [11,12,13,14])
print(ar)

Output:

array('i', [11,12,13,14])

2. append():

This method adds the specified value to the end of the array.

Syntax : array_name.append(item)

Example:

import array
arr = array.array('i', [1, 2, 3])
arr.append(4)
print(arr)

Output:

array('i', [1, 2, 3, 4])

3. remove():

This method eliminates the first instance of the supplied value from the array.

Syntax : array_name.remove(item)

Example:

import array
arr = array.array('i', [1, 2, 3, 2])
arr.remove(2)
print(arr)

Output:

array('i', [1, 3, 2])

4. sort():

The array's elements are sorted using this method.

Syntax : array_name.sort()

Example:

import array
arr = array.array('i', [5, 2, 1, 4, 3])
arr.sort()
print(arr)

Output:

array('i', [1, 2, 3, 4, 5])

5. extend():

This method adds the elements from the specified iterable to the end of the array.

Syntax : extend(iterable)

Example:

import array
arr1 = array.array('i', [1, 2, 3])
arr2 = array.array('i', [4, 5, 6])
arr1.extend(arr2)
print(arr1)

Output:

array('i', [1, 2, 3, 4, 5, 6])

6. insert():

This method inserts the specified value at the specified index.

Syntax : insert(index, value)

Example:

import array
arr = array.array('i', [1, 2, 3])
arr.insert(1, 4)
print(arr)

Output:

array('i', [1, 4, 2, 3])

7. pop():

The element at the supplied index is removed and returned by this method. If no index is specified, it removes and returns the last element.

Syntax : pop(index=-1)

Example:

import array
arr = array.array('i', [1, 2, 3])
removed_element = arr.pop(1)
print(arr)
print(removed_element)

Output:

array('i', [1, 3])
2

8. index():

The index() method returns the index of the first occurrence of a specified element in the array.

Syntax : array.index(element[, start[, end]])

Example:

import array
a = array.array('i', [1, 2, 3, 2])
print(a.index(2))

Output: 1

9. reverse():

The order of the array's elements is reversed by this method.

Syntax : reverse()

Example:

import array
arr = array.array('i', [1, 2, 3])
arr.reverse()
print(arr)

Output:

array('i', [3, 2, 1])

10. count():

This method returns the number of times the specified value appears in the array.

Syntax : count(value)

Example:

import array
arr = array.array('i', [1, 2, 3, 2])
count = arr.count(2)
print(count)

Output: 2

11. typecode:

The typecode attribute of an array returns the type code character used to create the array.

Syntax : array.typecode

Example:

import array
a = array.array('i', [1, 2, 3, 4])
print(a.typecode)

Output: "i"

12. itemsize:

The itemsize attribute of an array returns the size of each element in bytes.

Syntax : array.itemsize

Example:

import array
a = array.array('i', [1, 2, 3, 4])
print(a.itemsize)

Output: 4

13. buffer_info():

The buffer_info() method returns a tuple representing the address of the array's buffer and the size of the buffer in bytes.

Syntax : array.buffer_info()

Example:

import array
a = array.array('i', [1, 2, 3, 4])
print(a.buffer_info())

Output: (139953048219200, 16)

14. fromlist():

The fromlist() method appends a list to the end of an array.

Syntax : array.fromlist(list)

Example:

import array
ar = array.array('i', [1, 2, 3, 4])
ar.fromlist([15, 16, 17, 18])
print(ar)

Output:

array('i', [1, 2, 3, 4, 15, 16, 17, 18])

15. tolist():

The tolist() method returns a list containing all the elements of an array.

Syntax : array.tolist()

Example:

import array
a = array.array('i', [1, 2, 3, 4])
print(a.tolist())

Output:

[1, 2, 3, 4]

16. copy():

A shallow copy of the array is what is returned by the copy() method.

Syntax : array.copy()

Example:

import array
a = array.array('i', [11, 12, 13, 14])
cpy_a = a.copy()
print(cpy_a)

Output:

array('i', [11, 12, 13, 14])

17. clear():

The clear() method removes all the elements from the array.

Syntax : array.clear()

Example:

import array
a = array.array('i', [1, 2, 3, 4])
a.clear()
print(a)

Output:

array('i', [])

Awk

Manisha Kundrapu — Thu, 02 Feb 2023 06:04:18 +0000

Awk is utilised for data manipulation and report generation. The awk command does not require compilation and enables the usage of variables, string functions, numeric functions, and logical operators .

Awk allows programmers to create brief but powerful programmes in the form of statements that specify text patterns to be looked for in each line of a document and the action that should be taken when a match is found . Awk is primarily utilised for processing and scanning patterns . In order to determine whether any files include lines that fit the required patterns, it examines one or more of them . If so, it takes the appropriate steps .

The developers' names Aho, Weinberger, and Kernighan are shortened to Awk .

AWK operations include the following :

Line-by-line file scanning
Field splitting
Input line/field comparison with pattern
Executes an action on matched lines

Its often used for Producing prepared reports and transforming data files .

Programming constructs include output line formatting , string and arithmetic operations , conditionals and loops .

Built-In Variables In Awk

The field variables that divide a line of text into discrete words or parts known as fields are included in Awk as built-in variables and are denoted by the numbers $1, $2, $3, and so on ($0 is the complete line) .

NR: The NR command keeps track of the number of input records at all times .
NF: The NF command keeps track of how many fields are present in the current input record .
FS: Field separator characters are used to separate fields on the input line and are contained in the FS command . Space and tab characters or white space are used as the default . To modify the field separator, FS can be moved to another character (usually in BEGIN) .

Syntax :

awk options 'criteria {action}' input_file > output_file

-f program-file : Instead of reading from the first command line parameter, this is used to read the AWK programme source from . the file program-file.
-F fs : Use fs for the input field separator .

Examples:

Using Awk to print every line from a specified file :

$ awk '{print}' <filename>

Printing the lines which match the given pattern in the specific file :

$ awk '/pattern/ {print}' <filename>

For splitting Line Into Fields :

The awk command breaks each record, or line, into separate records that are by default separated by whitespace characters and stored in the $n variables . It will be saved in $1, $2, $3, and $4, accordingly, if the line contains 4 words. Furthermore, $0 denotes the entire line .

$ awk '{print $1,$2}' record.txt

Using the built-in NR variables for displaying the line number : Consider the below example for displaying line number on every line in the text file .

$ awk '{print NR,$0}' <filename>

Using the built-in NF variables for displaying the last field :

$ awk '{print $NF}' <filename>

Using NR built-in variables to Display Lines in between range :

Consider below example to print all the line details from 3 to 6 lines in the file .

$ awk 'NR==3, NR==6 {print NR,$0}' <filename>

For the given text file:

$cat > a.txt

Anil      Bela    Clara
Tasha     priya   naina
Menaka    sita    krishn
Praveena  ram     dia

Consider the below example To print the first item including the row number(NR) separated with ” – “ from each line in a.txt :

$ awk '{print NR "- " $1 }' a.txt

Output :

1 - Anil
2 - Menaka
3 – Menaka    
4 - Praveena

To return the second column/item from a.txt:

Consider the below exapmple to return the second column/item from a.txt :

$ awk '{print $2}' a.txt

Output:

Bela
priya
sita
ram

Printing a non-empty line :

awk ‘NF == 0 {print NR}’  <filename>

awk ‘NF <= 0 {print NR}’  <filename>

To count the lines in a file :

$ awk 'END { print NR }' <filename>