Python Pandas Performance Tunning

Performance tuning is an important aspect of working with large datasets in pandas, a popular data manipulation library in Python. In this tutorial, we will explore various techniques for improving the performance of pandas operations and optimizing memory usage.

Before we dive into performance tuning techniques, it is important to understand the basics of how pandas stores and manipulates data. Pandas uses a data structure called a DataFrame to store data in tabular form. By default, pandas uses NumPy arrays to store data in DataFrames, which allows for fast numerical computations. However, this can lead to increased memory usage and slow performance when working with large datasets.

Optimizing Memory Usage:

One of the most important factors affecting pandas performance is memory usage. To minimize memory usage, it is important to use the appropriate data types for columns in a DataFrame. For example, using the 'int' data type instead of 'float' when dealing with integers can significantly reduce memory usage. To check the data types of columns in a DataFrame, use the 'dtypes' attribute.

import pandas as pd

# Load data into a pandas DataFrame

df = pd.read_csv('data.csv')

# Check data types of columns in the DataFrame

print(df.dtypes)

Another way to reduce memory usage is to use the 'astype' method to explicitly cast columns to the appropriate data type.

# Cast a column to a specific data type

df['column_name'] = df['column_name'].astype('int32')

Avoiding Common Performance Pitfalls:

There are several common performance pitfalls to be aware of when working with pandas DataFrames. One of these is using the 'iterrows' method, which can be slow and inefficient when working with large datasets. A better alternative is to use vectorized operations, which allow for fast computations on entire arrays.

# Slow way of iterating over a DataFrame using the 'iterrows' method

for index, row in df.iterrows():

    # Perform computations on the row

    result = row['column1'] + row['column2']

# Fast way of performing computations using vectorized operations

result = df['column1'] + df['column2']

Another common performance pitfall is using the 'apply' method on entire DataFrames, as this can also be slow and inefficient. A better alternative is to use vectorized operations or to use the 'apply' method on specific columns.

# Slow way of using the 'apply' method on a entire DataFrame

result = df.apply(lambda x: x['column1'] + x['column2'], axis=1)

# Fast way of using the 'apply' method on specific columns

result = df[['column1', 'column2']].apply(lambda x: x['column1'] + x['column2'], axis=1)

Using Cython:

Cython is a language that is a superset of Python and can be used to optimize the performance of pandas operations. To use Cython, you need to install it and write Cython code in a separate file. Cython code can then be compiled and imported into a Python script.

# Cython code

def sum_columns(df):

    result = df['column1'] + df['column2']

    return result

 

 

 

 

Using 'dtype' and 'usecols' parameters in 'read_csv':

When reading large datasets into pandas, it is often useful to specify the data types of columns and only load the columns you need. This can be done using the 'dtype' and 'usecols' parameters in the 'read_csv' function.

# Specify data types of columns and only load specific columns

dtype = {'column1': 'int32', 'column2': 'float32'}

usecols = ['column1', 'column2']

df = pd.read_csv('data.csv', dtype=dtype, usecols=usecols)

Using 'query' method:

The 'query' method in pandas allows you to filter a DataFrame based on a query expression. This can be faster than using boolean indexing, especially for large datasets.

# Filter a DataFrame using the 'query' method

df = df.query('column1 > 0 and column2 < 1')

Using 'numpy' functions:

NumPy is a library for numerical computing in Python and is used by pandas for storing and manipulating data. Using NumPy functions directly can be faster than using pandas functions, especially for numerical computations.

# Use NumPy functions for numerical computations

import numpy as np

result = np.add(df['column1'], df['column2'])

These are some of the techniques for improving the performance of pandas operations. By optimizing memory usage, avoiding common performance pitfalls, and using tools such as Cython, vectorized operations, and NumPy, you can significantly improve the speed and efficiency of your pandas scripts.

In conclusion, performance tuning is an important aspect of working with pandas and big datasets. By following best practices and techniques such as using 'dtype' and 'usecols' parameters in 'read_csv', the 'query' method, and NumPy functions, you can significantly improve the speed and efficiency of your pandas operations. Additionally, it is important to continuously monitor and test the performance of your code to identify any bottlenecks and make further optimizations as needed. By taking the time to optimize your pandas operations, you can save time and resources while making your data analysis more effective.

 

Python Pandas Advanced Topics

 

 Data analysis is a critical component of decision-making in various industries, including business, finance, and healthcare. One important aspect of data analysis is the ability to manipulate and summarize large datasets. Advanced topics such as time series data, cross-tabulation, and pivot tables are essential for this task.

Time Series Data

Time series data refers to data that is collected over time and is often used to analyze trends and patterns. The data is usually in the form of time-stamped records and is commonly used in finance, economics, and weather forecasting.

One common method for analyzing time series data is decomposition. Decomposition is the process of separating a time series into its components, including trend, seasonality, and residuals. The trend component is a smooth representation of the overall direction of the data, while the seasonality component represents repeating patterns in the data. The residual component represents the random variation in the data that is not explained by trend or seasonality.

Here is an example code for decomposing a time series data using the statsmodels library in Python:

import statsmodels.api as sm

import matplotlib.pyplot as plt

data = sm.datasets.sunspots.load_pandas().data

data.index = data['YEAR']

data = data['SUNACTIVITY']

decomposition = sm.tsa.seasonal_decompose( data, model='additive',period = 1)

trend = decomposition.trend

seasonal = decomposition.seasonal

resid = decomposition.resid

plt.subplot(411)

plt.plot(data, label='Original')

plt.legend(loc='best')

plt.subplot(411)

plt.plot(trend,label = "Trend")

plt.legend(loc = "best")

plt.subplot(411)

plt.plot(seasonal,label = "Seasonal")

plt.legend(loc = "best")

plt.subplot(411)

plt.plot(resid,label = "Resid")

plt.legend(loc = "best")

Cross-Tabulation

Cross-tabulation, also known as contingency table analysis, is a technique used to summarize and analyze the relationship between two or more categorical variables. The goal of cross-tabulation is to determine if there is a significant association between the variables and to measure the strength of that association.

One common method for analyzing cross-tabulation data is chi-squared test. The chi-squared test is a statistical test used to determine if there is a significant association between two categorical variables. The test is based on the calculation of a statistic that measures the difference between the expected and observed frequencies in a contingency table.

 Here is an example code for conducting a chi-squared test using the scipy library in Python:

import pandas as pd

from scipy.stats import chi2_contingency

data = pd.read_csv('data.csv')

table = pd.crosstab(data['Variable 1'], data['Variable 2'])

stat, p, dof, expected = chi2_contingency(table)

if p < 0.05:

    print('There is a significant association between the variables')

else:

    print('There is no significant association between the variables')

In this code, we first import the necessary libraries pandas and scipy. Then, we read in a sample dataset data.csv using pd.read_csv(). Next, we create a contingency table using the pd.crosstab() function and pass in the two variables that we want to analyze. Finally, we conduct the chi-squared test using chi2_contingency() and store the results in variables stat, p, dof, and expected. If the p value is less than 0.05, it indicates that there is a significant association between the variables, otherwise, there is no significant association.

Pivot Tables

Pivot tables are a powerful tool for summarizing and aggregating large datasets. They are used to calculate summary statistics and to transform raw data into a more readable and understandable format. Pivot tables can be used to analyze large datasets in a way that is easily understood by a wide audience.

Here is an example code for creating a pivot table using the pandas library in Python:

import pandas as pd

data = pd.read_csv('data.csv')

pivot_table = data.pivot_table(values='Value', index='Variable 1', columns='Variable 2', aggfunc='mean')

print(pivot_table)

In this code, we first import the necessary library pandas. Then, we read in a sample dataset data.csv using pd.read_csv(). Next, we create a pivot table using the pivot_table() function and pass in the following parameters:

• values: the column in the dataset that we want to aggregate
• index: the column that we want to use as the row index
• columns: the column that we want to use as the column index
• aggfunc: the aggregation function that we want to use (in this case, we use the mean function)

The resulting pivot table will display the mean values of the Value column for each combination of Variable 1 and Variable 2.

Conclusion

In conclusion, advanced topics such as time series data, cross-tabulation, and pivot tables are essential for data analysis and manipulation. Understanding and using these techniques can greatly improve the ability to analyze and present large datasets in a meaningful and easily understood way.

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.

 

Python Pandas Data Manipulation

Data manipulation is a crucial step in the data analysis process. It involves transforming raw data into a format that can be used for analysis and visualization. In this article, we will discuss various techniques for manipulating data, including merging, joining, and concatenating. These techniques are used to combine multiple data sources into a single data set, making it easier to analyze and visualize the data.

Merging Data

Merging data is the process of combining two or more data sets into one. This is useful when you have data from multiple sources that you want to combine for analysis. For example, you may have sales data from two different regions that you want to merge into one data set to compare the sales from each region.

In Python, you can use the pandas library to perform data merging. The pandas library provides a function called merge that can be used to merge two data sets based on a common column. Let's take a look at an example:

import pandas as pd

# Create two data sets

data1 = {'Region': ['North', 'South', 'East', 'West'],

         'Sales': [10000, 12000, 11000, 9000]}

data2 = {'Region': ['North', 'South', 'East', 'West'],

         'Revenue': [20000, 22000, 21000, 19000]}

# Convert the data into data frames

df1 = pd.DataFrame(data1)

df2 = pd.DataFrame(data2)

# Merge the data frames based on the 'Region' column

merged_df = pd.merge(df1, df2, on='Region')

print(merged_df)

This code creates two data sets, data1 and data2, which contain sales data from different regions. The data sets are then converted into data frames df1 and df2. The pd.merge function is then used to merge the data frames based on the common column 'Region'. The resulting data frame, merged_df, contains both the sales and revenue data for each region.

Joining Data

Joining data is a similar process to merging data, but it uses a different method to combine the data. In a join, data is combined based on the values in the common columns of both data sets. There are three types of joins: inner join, outer join, and left join.

An inner join combines only the rows from both data sets that have matching values in the common columns. An outer join combines all the rows from both data sets, including the rows that do not have matching values in the common columns. A left join combines all the rows from the left data set and only the rows from the right data set that have matching values in the common columns.

Let's take a look at an example of an inner join:

  

import pandas as pd

# Create two data sets

data1 = {'Region': ['North', 'South', 'East', 'West'],

         'Sales': [10000, 12000, 11000, 9000]}

data2 = {'Region': ['North', 'South', 'East', 'West'],

         'Revenue': [20000, 22000, 21000, 19000]}

# Convert the data into data frames

df1 = pd.DataFrame(data1)

df2 = pd.DataFrame(data2)

# Perform an inner join on the 'Region' column

inner_join = df1.merge(df2, on='Region', how='inner')

print(inner_join)

This code creates two data sets, data1 and data2, which contain sales and revenue data from different regions. The data sets are then converted into data frames df1 and df2. The merge function is used to perform an inner join on the Region column. The resulting data frame, inner_join, contains only the rows where there is a matching value in the Region column in both df1 and df2.

In this example, the resulting data frame inner_join contains the same values as the merged data frame in the previous example, as an inner join will only retain the rows that have matching values in both data sets.

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.

 

 

Python Pandas Data Transformation

 

 Data Transformation is a crucial step in the data analysis process. It involves converting raw data into a format that can be easily analyzed and understood. In this article, we will explore the various techniques for transforming data, including selecting and filtering data, groupby operations, and reshaping data. We will use examples in Python for illustration.

     Selecting and Filtering Data

Selecting and filtering data refers to the process of extracting a subset of data from a larger dataset. There are two main methods for selecting and filtering data:

1. Indexing: This method involves selecting specific rows or columns based on their position or label. For instance, to select the first 5 rows of a pandas DataFrame, you can use the following code:

import pandas as pd

df = pd.read_csv('data.csv')

df = df[:5]

2. Boolean Indexing: This method involves selecting data based on a boolean condition. For instance, to select all rows where the value of a particular column is greater than a specified value, you can use the following code:

import pandas as pd

df = pd.read_csv('data.csv')

df = df[df['column_name'] > value]

Groupby Operations

The groupby operation is a powerful tool for aggregating and summarizing data. It involves dividing a DataFrame into groups based on the values of one or more columns, and then aggregating data within each group. For instance, to calculate the mean of a column for each unique value in another column, you can use the following code:

import pandas as pd

df = pd.read_csv('data.csv')

grouped = df.groupby('column_name')

result = grouped['aggregate_column'].mean()

Reshaping Data

Reshaping data refers to converting data from one format to another, typically for the purpose of making it easier to analyze. There are two main techniques for reshaping data:

1. Pivot Tables: Pivot tables are a powerful tool for aggregating and summarizing data. They involve creating a multi-dimensional table where one or more columns are used to index the data, and another column is used to calculate the aggregate. For instance, to create a pivot table that calculates the mean of a column for each unique value in two other columns, you can use the following code:

import pandas as pd

df = pd.read_csv('data.csv')

pivot_table = df.pivot_table(index='column1', columns='column2', values='aggregate_column', aggfunc='mean')

2. Melt: The melt operation is the opposite of pivot_table, and involves converting a pivot table back into a long format. For instance, to melt a pivot table back into a DataFrame, you can use the following code:

import pandas as pd

df = pd.read_csv('data.csv')

melted = df.melt(id_vars='column1', value_vars=['column2', 'column3'], value_name='aggregate_column')

In conclusion, data transformation is an important step in the data analysis process. By selecting and filtering data, aggregating and summarizing data using groupby operations, and reshaping data using pivot tables and melt operations.

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.

 

Python pandas data exploration and Visualization

 

Data Exploration: Techniques for Exploring and Summarizing Data

Data exploration is an important step in the data analysis process as it helps to understand the structure, distribution and relationships of the data before further analysis. This stage is crucial to identify potential outliers, missing values, trends and patterns in the data. In this article, we will learn about some common techniques for exploring and summarizing data, including descriptive statistics and data visualization.

1. Descriptive Statistics Descriptive statistics summarize the central tendencies and dispersion of the data. The following are some of the commonly used descriptive statistics measures:

• Mean: The average value of the data.
• Median: The middle value of the data.
• Mode: The most frequently occurring value in the data.
• Range: The difference between the highest and the lowest values in the data.
• Variance: The average of the squared differences from the mean.
• Standard Deviation: The square root of the variance.

Example code in Python:

import numpy as np

# Define the data

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Mean

mean = np.mean(data)

print("Mean: ", mean)

 #output -> Mean :5.5

# Median

median = np.median(data)

print("Median: ", median)

 #output -> Median : 5.5

# Mode

from statistics import mode

mode = mode(data)

print("Mode: ", mode)

 #output -> Mode : 1

# Range

range = np.ptp(data)

print("Range: ", range)

 #output -> Range : 9

# Variance

variance = np.var(data)

print("Variance: ", variance)

 #output -> Variance : 8.25

# Standard Deviation

std_dev = np.std(data)

print("Standard Deviation: ", std_dev)

#output -> Standard Deviation : 2.8722813232690143

2. Data Visualization Data visualization is a powerful tool for exploring and summarizing data. It helps to understand the data better and uncover hidden patterns and trends. Some common data visualization techniques are:

• Line Plot: A line plot is used to represent continuous data over time.
• Scatter Plot: A scatter plot is used to visualize the relationship between two variables.
• Histogram: A histogram represents the distribution of the data.
• Box Plot: A box plot represents the distribution of the data and highlights any outliers.

Example code in Python using Matplotlib library:

import matplotlib.pyplot as plt

# Define the data

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Line Plot

plt.plot(data)

plt.title("Line Plot")

plt.show()

# Scatter Plot

x = [1, 2, 3, 4, 5]

y = [2, 4, 6, 8, 10]

plt.scatter(x, y)

plt.title("Scatter Plot")

plt.show()

# Histogram

plt.hist(data, bins=5)

plt.title("Histogram")

plt.show()

You can play with "bins" value.

# Box Plot

plt.boxplot(data)

plt.title("Box Plot")

plt.show()

In conclusion, data exploration is an important step in the data analysis process. Descriptive statistics and data visualization are two important techniques for exploring and summarizing data. 

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.

Data Cleaning and Preperation

 

Data Cleaning and Preparation: Essential Techniques for Effective Data Analysis

Data preparation is an important step in the data analysis process. Cleaning and preparing data is crucial because if the data is not accurate, then the analysis and predictions made from it will also be inaccurate. In this article, we will discuss three essential techniques for cleaning and preparing data: handling missing values, handling outliers, and working with duplicate data.

1. Handling Missing Values

Missing values are a common problem in datasets. The missing values can occur due to many reasons, such as data collection errors, incompleteness of the data, or data loss during data transmission. To handle missing values, there are several techniques available, including:

·        Deletion: Deletion is the simplest method to handle missing values. This method involves removing the rows or columns with missing values from the dataset. However, this method may lead to loss of important information, especially if a large number of values are missing.

·        Imputation: Imputation is a process of replacing missing values with estimated values. There are several imputation methods, including mean imputation, median imputation, and mode imputation.

Here's an example of how to perform mean imputation in Python using Pandas:

import pandas as pd

import numpy as np

df = pd.read_csv("data.csv")

df.fillna(df.mean(), inplace=True)

2. Handling Outliers

Outliers are extreme values that deviate significantly from the other values in the dataset. Outliers can have a significant impact on the results of the analysis and predictions. To handle outliers, there are several techniques available, including:

·        Z-Score: Z-score is a statistical method that measures the number of standard deviations away from the mean. Any value with a Z-score greater than 3 or less than -3 is considered an outlier.

·        Interquartile Range (IQR): IQR is a statistical measure that separates the upper and lower 25% of the data. Any value outside of the IQR range is considered an outlier.

Here's an example of how to detect and remove outliers in Python using Z-Score:

import pandas as pd

import numpy as np

df = pd.read_csv("data.csv")

z_score = np.abs(zscore(df))

df = df[(z_score < 3).all(axis=1)]

3. Working with Duplicate Data

Duplicate data is a common problem in datasets. Duplicate data can lead to inaccurate results and conclusions. To handle duplicate data, there are several techniques available, including:

·        Drop Duplicates: Drop Duplicates is a method that involves removing all duplicate rows from the dataset.

·        Merge Duplicates: Merge Duplicates is a method that involves combining all the information from duplicate rows into a single row.

Here's an example of how to drop duplicates in Python using Pandas:

import pandas as pd

df = pd.read_csv("data.csv")

df.drop_duplicates(inplace=True)

In conclusion, data cleaning and preparation are critical steps in the data analysis process. By handling missing values, outliers, and duplicate data, you can ensure that the data is accurate and ready for analysis. With these techniques, you can make informed decisions and accurate predictions based on your data.

 

Data input and Output in Python Pandas

 

Data Input and Output is an essential aspect of working with pandas. The library provides several functions and methods to read and write data to and from different file formats. In this article, we will discuss how to read and write data to and from CSV, Excel, JSON, and SQL file formats using pandas.

CSV

Comma Separated Values (CSV) is one of the most widely used file formats for storing data. pandas provides the read_csv and to_csv functions to read and write CSV files, respectively.

To read a CSV file, use the read_csv() function and pass the file path as an argument. The function returns a DataFrame object.

import pandas as pd

df = pd.read_csv('data.csv')

The read_csv() function also accepts several optional parameters to customize the reading process. For example, you can use the header parameter to specify the row number to use as the column names, or use the names parameter to provide a list of column names.

To write a DataFrame to a CSV file, use the to_csv() function and pass the file path as an argument.

df.to_csv('data_modified.csv', index=False)

The to_csv() function also accepts several optional parameters to customize the writing process. For example, you can use the sep parameter to specify the separator character to use between fields, or use the index parameter to specify whether to write the row index to the file.

Excel

Excel is another widely used file format for storing data. pandas provides the read_excel and to_excel functions to read and write Excel files, respectively.

To read an Excel file, use the read_excel() function and pass the file path as an argument. The function returns a DataFrame object.

df = pd.read_excel('data.xlsx')

The read_excel() function also accepts several optional parameters to customize the reading process. For example, you can use the sheet_name parameter to specify the sheet to read from the Excel file, or use the usecols parameter to specify the columns to read.

To write a DataFrame to an Excel file, use the to_excel() function and pass the file path as an argument.

df.to_excel('data_modified.xlsx', index=False)

The to_excel() function also accepts several optional parameters to customize the writing process. For example, you can use the engine parameter to specify the engine to use when writing to the file, or use the columns parameter to specify the columns to write.

JSON

JavaScript Object Notation (JSON) is a lightweight data interchange format. pandas provides the read_json and to_json functions to read and write JSON files, respectively.

To read a JSON file, use the read_json() function and pass the file path as an argument. The function returns a DataFrame object.

df = pd.read_json('data.json')

 

Python Pandas series

 

The Pandas library in Python is a powerful tool for data manipulation and analysis. It provides data structures such as Series and DataFrame that allow you to work with and manipulate data in a flexible and efficient way.

A Series is a one-dimensional array-like object that can hold any data type. It is similar to a column in a spreadsheet or a dataset in R. Each Series has a name, called the index, which is used to identify the elements in the Series.

Here is an example of creating a Series in Pandas:

import pandas as pd

data = [1, 2, 3, 4, 5]

index = ['a', 'b', 'c', 'd', 'e']

s = pd.Series(data, index=index)

print(s)

This will output:

a    1

b    2

c    3

d    4

e    5

dtype: int64

In the example above, we created a Series called "s" with the data [1, 2, 3, 4, 5] and the index ['a', 'b', 'c', 'd', 'e']. The elements in the Series can be accessed by their index, just like in a dictionary. For example, to access the element at index 'c', we can use the following code:

print(s['c'])

This will output:

3

We can also perform mathematical operations on the elements of a Series, like adding or multiplying them. For example:

s2 = s * 2

print(s2)

This will output:

a     2

b     4

c     6

d     8

e    10

dtype: int64

In addition to these basic operations, the Pandas library provides a wide range of methods for working with Series, such as sorting, filtering, and aggregating data. These methods allow you to easily manipulate and analyze your data, making Pandas a valuable tool for data science and machine learning tasks.

In summary, Pandas Series is a powerful data structure that allows you to work with and manipulate data in a flexible and efficient way. With the wide range of methods provided by the Pandas library, you can easily sort, filter, and aggregate your data, making it a valuable tool for data science and machine learning tasks.

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.

 

Python Pandas Introduction

 

Python Pandas is a powerful library for data manipulation and analysis. It provides a wide range of data structures and operations for manipulating numerical tables and time series data.

The most important data structure in Pandas is the DataFrame, which is a table with labeled rows and columns. DataFrames can be created from a variety of data sources such as CSV files, Excel sheets, SQL databases, and even Python lists and dictionaries. They can also be easily exported to a variety of formats, such as CSV, Excel, and JSON.

One of the key features of Pandas is its ability to handle missing data. It provides a variety of methods for filling in missing values, such as forward filling, backward filling, and interpolation. This makes it easy to work with incomplete datasets.

Another powerful feature of Pandas is its ability to perform groupby operations. This allows you to group rows in a DataFrame based on the values in one or more columns, and then apply a variety of aggregation functions to each group, such as sum, mean, and count.

Pandas also provides a wide range of tools for data manipulation and cleaning, such as filtering, sorting, and reshaping data. It also supports advanced features such as merging, joining, and concatenating DataFrames.

In addition to DataFrames, Pandas also provides a Series object, which is a one-dimensional array-like object with a labeled index. Series can be used for a variety of tasks such as data cleaning and transformation, and can also be easily converted to and from a DataFrame.

Overall, Pandas is a powerful and flexible tool for data manipulation and analysis, and is widely used in data science and machine learning projects.

To get started with Pandas, you will need to install it first. You can do this by running "pip install pandas" in your command line or terminal. Once it's installed, you can start using it by importing it in your code like this: "import pandas as pd".

A simple example of how to use pandas is by loading a csv file into a dataframe and then printing first 5 rows.

import pandas as pd

df = pd.read_csv("your_file.csv")

print(df.head())

This is just an introduction to the capabilities of Python Pandas library, but the possibilities are endless and it's a fundamental tool for data manipulation and analysis.

Amelioration

This article was researched and written with the help of ChatGPT, a language model developed by OpenAI.

Special thanks to ChatGPT for providing valuable information and examples used in this article.