From 3f51f48ee55690c7f64e591a729d9cb034264ca4 Mon Sep 17 00:00:00 2001
From: SAM <8dmasters@gmail.com>
Date: Fri, 31 May 2024 10:00:10 +0530
Subject: [PATCH 01/76] Create Transformers.md

Added a empty .md file to be served as a guide for Transformers
---
 contrib/machine-learning/Transformers.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 contrib/machine-learning/Transformers.md

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
new file mode 100644
index 0000000..e69de29

From b832f8f0c90673462ecc990f45595761565b027d Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 13:40:20 +0530
Subject: [PATCH 02/76] Update Transformers.md

Added topics
---
 contrib/machine-learning/Transformers.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index e69de29..7bcc102 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -0,0 +1,21 @@
+# Transformers
+## Introduction
+A transformer is a deep learning architecture developed by Google and based on the multi-head attention mechanism. It is based on the softmax-based attention 
+mechanism. Before transformers, predecessors of attention mechanism were added to gated recurrent neural networks, such as LSTMs and gated recurrent units (GRUs), which 
+processed datasets sequentially. Dependency on previous token computations prevented them from being able to parallelize the attention mechanism.
+
+## Key Concepts
+
+## Architecture
+
+## Implementation
+### Theory
+Text is converted to numerical representations called tokens, and each token is converted into a vector via looking up from a word embedding table. 
+At each layer, each token is then contextualized within the scope of the context window with other tokens via a parallel multi-head attention mechanism 
+allowing the signal for key tokens to be amplified and less important tokens to be diminished.
+
+### HuggingFace
+
+### Tensorflow and Keras
+
+### PyTorch

From 5b3c8d7ad108d4a65b4a946d719d242fe9eae308 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 15:14:09 +0530
Subject: [PATCH 03/76] Update Transformers.md

Added information about Model Architecture
---
 contrib/machine-learning/Transformers.md | 59 +++++++++++++++++++++++-
 1 file changed, 57 insertions(+), 2 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index 7bcc102..49a1b97 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -4,9 +4,53 @@ A transformer is a deep learning architecture developed by Google and based on t
 mechanism. Before transformers, predecessors of attention mechanism were added to gated recurrent neural networks, such as LSTMs and gated recurrent units (GRUs), which 
 processed datasets sequentially. Dependency on previous token computations prevented them from being able to parallelize the attention mechanism.
 
-## Key Concepts
+## Model Architecture
+<p align="center"><img src="https://github.com/SAM-DEV007/learn-python/assets/60264918/c290ed33-46ff-4b80-8212-47cfe7fbceb3" alt="Model Architecture" /></p>
 
-## Architecture
+### Encoder
+The encoder is composed of a stack of identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, positionwise fully connected feed-forward network. Each encoder consists of two major components: a self-attention mechanism and a feed-forward neural network. The self-attention mechanism accepts input encodings from the previous encoder and weights their relevance to each other to generate output encodings. The feed-forward neural network further processes each output encoding individually. These output encodings are then passed to the next encoder as its input, as well as to the decoders.
+
+### Decoder
+The decoder is also composed of a stack of identical layers. In addition to the two sub-layers in each encoder layer, the decoder inserts a third sub-layer, which performs multi-head attention over the output of the encoder stack. The decoder functions in a similar fashion to the encoder, but an additional attention mechanism is inserted which instead draws relevant information from the encodings generated by the encoders. This mechanism can also be called the encoder-decoder attention.
+
+### Attention
+#### Scaled Dot-Product Attention
+The input consists of queries and keys of dimension dk, and values of dimension dv. We compute the dot products of the query with all keys, divide each by √d<sub>k</sub>, and apply a softmax function to obtain the weights on the values.
+
+> Attention(Q, K, V) = softmax(QK<sup>T</sup> / √d<sub>k</sub>) * V
+
+#### Multi-Head Attention
+Instead of performing a single attention function with d<sub>model</sub>-dimensional keys, values and queries, it is beneficial to linearly project the queries, keys and values h times with different, learned linear projections to d<sub>k</sub>, d<sub>k</sub> and d<sub>v</sub> dimensions, respectively. 
+
+Multi-head attention allows the model to jointly attend to information from different representation
+subspaces at different positions. With a single attention head, averaging inhibits this.
+
+> MultiHead(Q, K, V) = Concat(head<sub>1</sub>, <sub>...</sub>, head<sub>h</sub>) * W<sup>O</sup>
+
+where,
+
+> head<sub>i</sub> = Attention(Q * W<sub>i</sub><sup>Q</sup>, K * W<sub>i</sub><sup>K</sup>, V * W<sub>i</sub><sup>V</sup>)
+
+where the projections are parameter matrices.
+
+#### Masked Attention
+It may be necessary to cut out attention links between some word-pairs. For example, the decoder for token position 
+𝑡 should not have access to token position 𝑡+1.
+
+> MaskedAttention(Q, K, V) = softmax(M + (QK<sup>T</sup> / √d<sub>k</sub>)) * V
+
+### Feed-Forward Network
+Each of the layers in the encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically. This
+consists of two linear transformations with a ReLU activation in between.
+> FFN(x) = (max(0, (x * W1) + b1) * W2) + b2
+
+### Positional Encoding
+A positional encoding is a fixed-size vector representation that encapsulates the relative positions of tokens within a target sequence: it provides the transformer model with information about where the words are in the input sequence.
+
+The sine and cosine functions of different frequencies:
+> PE<sub>(pos,2i)</sub> = sin(pos/10000<sup>2i/dmodel</sup>)
+
+> PE<sub>(pos,2i+1)</sub> = cos(pos/10000<sup>2i/dmodel</sup>)
 
 ## Implementation
 ### Theory
@@ -19,3 +63,14 @@ allowing the signal for key tokens to be amplified and less important tokens to
 ### Tensorflow and Keras
 
 ### PyTorch
+
+## Application
+The transformer has had great success in natural language processing (NLP). Many large language models such as GPT-2, GPT-3, GPT-4, Claude, BERT, XLNet, RoBERTa and ChatGPT demonstrate the ability of transformers to perform a wide variety of such NLP-related tasks, and have the potential to find real-world applications.
+
+These may include:
+- Machine translation
+- Document summarization
+- Text generation
+- Biological sequence analysis
+- Computer code generation
+- Video analysis

From 35357d2fe3f6650faca3d0f19327fe4fa7e8629d Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 17:04:07 +0530
Subject: [PATCH 04/76] Update Transformers.md

Added Tensorflow implementation
---
 contrib/machine-learning/Transformers.md | 136 ++++++++++++++++++++++-
 1 file changed, 134 insertions(+), 2 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index 49a1b97..a5a56ec 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -58,12 +58,144 @@ Text is converted to numerical representations called tokens, and each token is
 At each layer, each token is then contextualized within the scope of the context window with other tokens via a parallel multi-head attention mechanism 
 allowing the signal for key tokens to be amplified and less important tokens to be diminished.
 
-### HuggingFace
+### Tensorflow
+Tensorflow provides the transformer encoder and decoder block that can be implemented by the specification of the user. Although, the transformer is not provided as a standalone to be imported and executed, the user has to create the model first. They also have a tutorial on how to implement the transformer from scratch for machine translation and can be found [here](https://www.tensorflow.org/text/tutorials/transformer).
 
-### Tensorflow and Keras
+More information on [encoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerEncoderBlock) and [decoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerDecoderBlock) block mentioned in the code.
+
+Imports:
+```
+import tensorflow as tf
+import tensorflow_models as tfm
+```
+
+Adding word embeddings and positional encoding:
+```
+class PositionalEmbedding(tf.keras.layers.Layer):
+    def __init__(self, vocab_size, d_model):
+        super().__init__()
+        self.d_model = d_model
+        self.embedding = tf.keras.layers.Embedding(vocab_size, d_model, mask_zero=True) 
+        self.pos_encoding = tfm.nlp.layers.RelativePositionEmbedding(hidden_size=d_model)
+  
+    def compute_mask(self, *args, **kwargs):
+        return self.embedding.compute_mask(*args, **kwargs)
+  
+    def call(self, x):
+        length = tf.shape(x)[1]
+        x = self.embedding(x)
+        x = x + self.pos_encoding[tf.newaxis, :length, :]
+        return x
+```
+
+Creating the encoder for the transformer:
+```
+class Encoder(tf.keras.layers.Layer):
+    def __init__(self, num_layers, d_model, num_heads,
+                 dff, vocab_size, dropout_rate=0.1):
+        super().__init__()
+    
+        self.d_model = d_model
+        self.num_layers = num_layers
+    
+        self.pos_embedding = PositionalEmbedding(
+            vocab_size=vocab_size, d_model=d_model)
+    
+        self.enc_layers = [
+            tfm.nlp.layers.TransformerEncoderBlock(output_last_dim=d_model,
+                         num_attention_heads=num_heads,
+                         inner_dim=dff,
+                         inner_activation="relu",
+                         inner_dropout=dropout_rate)
+            for _ in range(num_layers)]
+        self.dropout = tf.keras.layers.Dropout(dropout_rate)
+
+    def call(self, x):
+        x = self.pos_embedding(x, length=2048)
+        x = self.dropout(x)
+    
+        for i in range(self.num_layers):
+          x = self.enc_layers[i](x)
+    
+        return x
+```
+
+Creating the decoder for the transformer:
+```
+class Decoder(tf.keras.layers.Layer):
+    def __init__(self, num_layers, d_model, num_heads, dff, vocab_size,
+                 dropout_rate=0.1):
+        super(Decoder, self).__init__()
+    
+        self.d_model = d_model
+        self.num_layers = num_layers
+    
+        self.pos_embedding = PositionalEmbedding(vocab_size=vocab_size,
+                                                 d_model=d_model)
+        self.dropout = tf.keras.layers.Dropout(dropout_rate)
+        self.dec_layers = [
+            tfm.nlp.layers.TransformerDecoderBlock(num_attention_heads=num_heads,
+                         intermediate_size=dff,
+                         intermediate_activation="relu",
+                         dropout_rate=dropout_rate)
+            for _ in range(num_layers)]
+  
+    def call(self, x, context):
+        x = self.pos_embedding(x)
+        x = self.dropout(x)
+    
+        for i in range(self.num_layers):
+            x  = self.dec_layers[i](x, context)
+  
+        return x
+```
+
+Combining the encoder and decoder to create the transformer:
+```
+class Transformer(tf.keras.Model):
+    def __init__(self, num_layers, d_model, num_heads, dff,
+                 input_vocab_size, target_vocab_size, dropout_rate=0.1):
+        super().__init__()
+        self.encoder = Encoder(num_layers=num_layers, d_model=d_model,
+                               num_heads=num_heads, dff=dff,
+                               vocab_size=input_vocab_size,
+                               dropout_rate=dropout_rate)
+      
+        self.decoder = Decoder(num_layers=num_layers, d_model=d_model,
+                               num_heads=num_heads, dff=dff,
+                               vocab_size=target_vocab_size,
+                               dropout_rate=dropout_rate)
+      
+        self.final_layer = tf.keras.layers.Dense(target_vocab_size)
+
+    def call(self, inputs):
+        context, x  = inputs
+    
+        context = self.encoder(context)
+        x = self.decoder(x, context)
+        logits = self.final_layer(x)
+    
+        return logits
+```
+
+Model initialization that be used for training and inference:
+```
+transformer = Transformer(
+      num_layers=num_layers,
+      d_model=d_model,
+      num_heads=num_heads,
+      dff=dff,
+      input_vocab_size=tokenizers.pt.get_vocab_size().numpy(),
+      target_vocab_size=tokenizers.en.get_vocab_size().numpy(),
+      dropout_rate=dropout_rate
+)
+```
 
 ### PyTorch
 
+
+### HuggingFace
+
 ## Application
 The transformer has had great success in natural language processing (NLP). Many large language models such as GPT-2, GPT-3, GPT-4, Claude, BERT, XLNet, RoBERTa and ChatGPT demonstrate the ability of transformers to perform a wide variety of such NLP-related tasks, and have the potential to find real-world applications.
 

From f56131349d1ad0e6e27209ea3d9217c13e695e8e Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 17:13:19 +0530
Subject: [PATCH 05/76] Update Transformers.md

Added python tag to code blocks
---
 contrib/machine-learning/Transformers.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index a5a56ec..ffdea05 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -64,13 +64,13 @@ Tensorflow provides the transformer encoder and decoder block that can be implem
 More information on [encoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerEncoderBlock) and [decoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerDecoderBlock) block mentioned in the code.
 
 Imports:
-```
+```python
 import tensorflow as tf
 import tensorflow_models as tfm
 ```
 
 Adding word embeddings and positional encoding:
-```
+```python
 class PositionalEmbedding(tf.keras.layers.Layer):
     def __init__(self, vocab_size, d_model):
         super().__init__()
@@ -89,7 +89,7 @@ class PositionalEmbedding(tf.keras.layers.Layer):
 ```
 
 Creating the encoder for the transformer:
-```
+```python
 class Encoder(tf.keras.layers.Layer):
     def __init__(self, num_layers, d_model, num_heads,
                  dff, vocab_size, dropout_rate=0.1):
@@ -121,7 +121,7 @@ class Encoder(tf.keras.layers.Layer):
 ```
 
 Creating the decoder for the transformer:
-```
+```python
 class Decoder(tf.keras.layers.Layer):
     def __init__(self, num_layers, d_model, num_heads, dff, vocab_size,
                  dropout_rate=0.1):
@@ -151,7 +151,7 @@ class Decoder(tf.keras.layers.Layer):
 ```
 
 Combining the encoder and decoder to create the transformer:
-```
+```python
 class Transformer(tf.keras.Model):
     def __init__(self, num_layers, d_model, num_heads, dff,
                  input_vocab_size, target_vocab_size, dropout_rate=0.1):
@@ -179,7 +179,7 @@ class Transformer(tf.keras.Model):
 ```
 
 Model initialization that be used for training and inference:
-```
+```python
 transformer = Transformer(
       num_layers=num_layers,
       d_model=d_model,

From ca9c6a9a1f23d1e6b5901954c8a5c5c772bd80a7 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 17:44:28 +0530
Subject: [PATCH 06/76] Update Transformers.md

Added PyTorch implementation
---
 contrib/machine-learning/Transformers.md | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index ffdea05..cb90cf1 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -56,7 +56,9 @@ The sine and cosine functions of different frequencies:
 ### Theory
 Text is converted to numerical representations called tokens, and each token is converted into a vector via looking up from a word embedding table. 
 At each layer, each token is then contextualized within the scope of the context window with other tokens via a parallel multi-head attention mechanism 
-allowing the signal for key tokens to be amplified and less important tokens to be diminished.
+allowing the signal for key tokens to be amplified and less important tokens to be diminished. 
+
+The transformer uses an encoder-decoder architecture. The encoder extracts features from an input sentence, and the decoder uses the features to produce an output sentence. Some architectures use full encoders and decoders, autoregressive encoders and decoders, or combination of both. This depends on the usage and context of the input.
 
 ### Tensorflow
 Tensorflow provides the transformer encoder and decoder block that can be implemented by the specification of the user. Although, the transformer is not provided as a standalone to be imported and executed, the user has to create the model first. They also have a tutorial on how to implement the transformer from scratch for machine translation and can be found [here](https://www.tensorflow.org/text/tutorials/transformer).
@@ -192,10 +194,30 @@ transformer = Transformer(
 ```
 
 ### PyTorch
+Unlike Tensorflow, PyTorch provides the full implementation of the transformer model that can be executed on the go. More information can be found [here](https://pytorch.org/docs/stable/_modules/torch/nn/modules/transformer.html#Transformer). A full implementation of the model can be found [here](https://github.com/pytorch/examples/tree/master/word_language_model).
 
+Imports:
+```python
+import torch
+import torch.nn as nn
+```
+
+Initializing the model:
+```python
+transformer = nn.Transformer(nhead=16, num_encoder_layers=8)
+```
+
+Sample Implementation:
+```python
+src = torch.rand((10, 32, 512))
+tgt = torch.rand((20, 32, 512))
+
+output = transformer(src, tgt)
+```
 
 ### HuggingFace
 
+
 ## Application
 The transformer has had great success in natural language processing (NLP). Many large language models such as GPT-2, GPT-3, GPT-4, Claude, BERT, XLNet, RoBERTa and ChatGPT demonstrate the ability of transformers to perform a wide variety of such NLP-related tasks, and have the potential to find real-world applications.
 

From d81e875a3235d7c9f50f9a42bb359bf80d3146a1 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 18:32:47 +0530
Subject: [PATCH 07/76] Update Transformers.md

Added outputs for PyTorch and HuggingFace implementation
---
 contrib/machine-learning/Transformers.md | 114 ++++++++++++++++++++++-
 1 file changed, 112 insertions(+), 2 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index cb90cf1..e9e50e8 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -61,6 +61,8 @@ allowing the signal for key tokens to be amplified and less important tokens to
 The transformer uses an encoder-decoder architecture. The encoder extracts features from an input sentence, and the decoder uses the features to produce an output sentence. Some architectures use full encoders and decoders, autoregressive encoders and decoders, or combination of both. This depends on the usage and context of the input.
 
 ### Tensorflow
+TensorFlow is a free and open-source software library for machine learning and artificial intelligence. It can be used across a range of tasks but has a particular focus on training and inference of deep neural networks. It was developed by the Google Brain team for Google's internal use in research and production.
+
 Tensorflow provides the transformer encoder and decoder block that can be implemented by the specification of the user. Although, the transformer is not provided as a standalone to be imported and executed, the user has to create the model first. They also have a tutorial on how to implement the transformer from scratch for machine translation and can be found [here](https://www.tensorflow.org/text/tutorials/transformer).
 
 More information on [encoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerEncoderBlock) and [decoder](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers/TransformerDecoderBlock) block mentioned in the code.
@@ -193,7 +195,22 @@ transformer = Transformer(
 )
 ```
 
+Sample:
+```python
+src = tf.random.uniform((64, 40))
+tgt = tf.random.uniform((64, 50))
+
+output = transformer((src, tgt))
+```
+
+O/P:
+```
+
+```
+
 ### PyTorch
+PyTorch is a machine learning library based on the Torch library, used for applications such as computer vision and natural language processing, originally developed by Meta AI and now part of the Linux Foundation umbrella. 
+
 Unlike Tensorflow, PyTorch provides the full implementation of the transformer model that can be executed on the go. More information can be found [here](https://pytorch.org/docs/stable/_modules/torch/nn/modules/transformer.html#Transformer). A full implementation of the model can be found [here](https://github.com/pytorch/examples/tree/master/word_language_model).
 
 Imports:
@@ -207,7 +224,7 @@ Initializing the model:
 transformer = nn.Transformer(nhead=16, num_encoder_layers=8)
 ```
 
-Sample Implementation:
+Sample:
 ```python
 src = torch.rand((10, 32, 512))
 tgt = torch.rand((20, 32, 512))
@@ -215,8 +232,101 @@ tgt = torch.rand((20, 32, 512))
 output = transformer(src, tgt)
 ```
 
-### HuggingFace
+O/P:
+```
+tensor([[[ 0.2938, -0.4824, -0.7816,  ...,  0.0742,  0.5162,  0.3632],
+         [-0.0786, -0.5241,  0.6384,  ...,  0.3462, -0.0618,  0.9943],
+         [ 0.7827,  0.1067, -0.1637,  ..., -1.7730, -0.3322, -0.0029],
+         ...,
+         [-0.3202,  0.2341, -0.0896,  ..., -0.9714, -0.1251, -0.0711],
+         [-0.1663, -0.5047, -0.0404,  ..., -0.9339,  0.3963,  0.1018],
+         [ 1.2834, -0.4400,  0.0486,  ..., -0.6876, -0.4752,  0.0180]],
 
+        [[ 0.9869, -0.7384, -1.0704,  ..., -0.9417,  1.3279, -0.1665],
+         [ 0.3445, -0.2454, -0.3644,  ..., -0.4856, -1.1004, -0.6819],
+         [ 0.7568, -0.3151, -0.5034,  ..., -1.2081, -0.7119,  0.3775],
+         ...,
+         [-0.0451, -0.7596,  0.0168,  ..., -0.8267, -0.3272,  1.0457],
+         [ 0.3150, -0.6588, -0.1840,  ...,  0.1822, -0.0653,  0.9053],
+         [ 0.8692, -0.3519,  0.3128,  ..., -1.8446, -0.2325, -0.8662]],
+
+        [[ 0.9719, -0.3113,  0.4637,  ..., -0.4422,  1.2348,  0.8274],
+         [ 0.3876, -0.9529, -0.7810,  ..., -0.5843, -1.1439, -0.3366],
+         [-0.5774,  0.3789, -0.2819,  ..., -1.4057,  0.4352,  0.1474],
+         ...,
+         [ 0.6899, -0.1146, -0.3297,  ..., -1.7059, -0.1750,  0.4203],
+         [ 0.3689, -0.5174, -0.1253,  ...,  0.1417,  0.4159,  0.7560],
+         [ 0.5024, -0.7996,  0.1592,  ..., -0.8344, -1.1125,  0.4736]],
+
+        ...,
+
+        [[ 0.0704, -0.3971, -0.2768,  ..., -1.9929,  0.8608,  1.2264],
+         [ 0.4013, -0.0962, -0.0965,  ..., -0.4452, -0.8682, -0.4593],
+         [ 0.1656,  0.5224, -0.1723,  ..., -1.5785,  0.3219,  1.1507],
+         ...,
+         [-0.9443,  0.4653,  0.2936,  ..., -0.9840, -0.0142, -0.1595],
+         [-0.6544, -0.3294, -0.0803,  ...,  0.1623, -0.5061,  0.9824],
+         [-0.0978, -1.0023, -0.6915,  ..., -0.2296, -0.0594, -0.4715]],
+
+        [[ 0.6531, -0.9285, -0.0331,  ..., -1.1481,  0.7768, -0.7321],
+         [ 0.3325, -0.6683, -0.6083,  ..., -0.4501,  0.2289,  0.3573],
+         [-0.6750,  0.4600, -0.8512,  ..., -2.0097, -0.5159,  0.2773],
+         ...,
+         [-1.4356, -1.0135,  0.0081,  ..., -1.2985, -0.3715, -0.2678],
+         [ 0.0546, -0.2111, -0.0965,  ..., -0.3822, -0.4612,  1.6217],
+         [ 0.7700, -0.5309, -0.1754,  ..., -2.2807, -0.0320, -1.5551]],
+
+        [[ 0.2399, -0.9659,  0.1086,  ..., -1.1756,  0.4063,  0.0615],
+         [-0.2202, -0.7972, -0.5024,  ..., -0.9126, -1.5248,  0.2418],
+         [ 0.5215,  0.4540,  0.0036,  ..., -0.2135,  0.2145,  0.6638],
+         ...,
+         [-0.2190, -0.4967,  0.7149,  ..., -0.3324,  0.3502,  1.0624],
+         [-0.0108, -0.9205, -0.1315,  ..., -1.0153,  0.2989,  1.1415],
+         [ 1.1284, -0.6560,  0.6755,  ..., -1.2157,  0.8580, -0.5022]]],
+       grad_fn=<NativeLayerNormBackward0>)
+```
+```
+>> output.shape
+torch.Size([20, 32, 512])
+```
+
+### HuggingFace
+Hugging Face, Inc. is a French-American company incorporated under the Delaware General Corporation Law and based in New York City that develops computation tools for building applications using machine learning.
+
+It has a wide-range of models that can implemented in Tensorflow, PyTorch and other development backends as well. The models are already trained on a dataset and can be pretrained on custom dataset for customized use, according to the user. The information for training the model and loading the pretrained model can be found [here](https://huggingface.co/docs/transformers/en/training).
+
+In HuggingFace, `pipeline` is used to run inference from the trained model available in the Hub. This is very beginner friendly. The model is downloaded to the local system on running the script before running the inference. It has to be made sure that the model downloaded does not exceed your available data plan.
+
+Imports:
+```python
+from transformers import pipeline
+```
+
+Initialization:
+
+The model used here is BART (large) which was trained on MultiNLI dataset, which consist of sentence paired with its textual entailment.
+```python
+classifier = pipeline(model="facebook/bart-large-mnli")
+```
+
+Sample:
+
+The first argument is the sentence which needs to be analyzed. The second argument, `candidate_labels`, is the list of labels which most likely the first argument sentence belongs to. The output dictionary will have a key as `score`, where the highest index is the textual entailment of the sentence with the index of the label in the list.
+
+```python
+output = classifier(
+    "I need to leave but later",
+    candidate_labels=["urgent", "not urgent", "sleep"],
+)
+```
+
+O/P:
+
+```
+{'sequence': 'I need to leave but later',
+ 'labels': ['not urgent', 'urgent', 'sleep'],
+ 'scores': [0.8889380097389221, 0.10631518065929413, 0.00474683940410614]}
+```
 
 ## Application
 The transformer has had great success in natural language processing (NLP). Many large language models such as GPT-2, GPT-3, GPT-4, Claude, BERT, XLNet, RoBERTa and ChatGPT demonstrate the ability of transformers to perform a wide variety of such NLP-related tasks, and have the potential to find real-world applications.

From 251c4d86894b26e113b1b4426aeaf412c0b4c977 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 18:43:19 +0530
Subject: [PATCH 08/76] Update Transformers.md

Added Tensorflow output and fixed wrong mentions
---
 contrib/machine-learning/Transformers.md | 93 +++++++++++++++++++++++-
 1 file changed, 91 insertions(+), 2 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index e9e50e8..d30bd63 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -189,8 +189,8 @@ transformer = Transformer(
       d_model=d_model,
       num_heads=num_heads,
       dff=dff,
-      input_vocab_size=tokenizers.pt.get_vocab_size().numpy(),
-      target_vocab_size=tokenizers.en.get_vocab_size().numpy(),
+      input_vocab_size=64,
+      target_vocab_size=64,
       dropout_rate=dropout_rate
 )
 ```
@@ -205,7 +205,96 @@ output = transformer((src, tgt))
 
 O/P:
 ```
+<tf.Tensor: shape=(64, 50, 64), dtype=float32, numpy=
+array([[[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]],
 
+       [[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]],
+
+       [[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]],
+
+       ...,
+
+       [[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]],
+
+       [[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]],
+
+       [[ 0.78274703, -1.2312567 ,  0.7272992 , ...,  2.1805947 ,
+          1.3511044 , -1.275499  ],
+        [ 0.82658154, -1.2863302 ,  0.76494133, ...,  2.39311   ,
+          1.0973787 , -1.3414565 ],
+        [ 0.57013685, -1.3958443 ,  1.0213287 , ...,  2.3791933 ,
+          0.58439416, -0.93464035],
+        ...,
+        [ 0.82214123, -0.51090807,  0.25897795, ...,  2.1979148 ,
+          1.4126635 , -0.5771998 ],
+        [ 0.6371507 , -0.36584622,  0.40954843, ...,  2.0241373 ,
+          1.6503414 , -0.74359566],
+        [ 0.6739802 , -0.39973688,  0.3338765 , ...,  1.6819229 ,
+          1.7505672 , -1.0763712 ]]], dtype=float32)>
+```
+```
+>>> output.shape
+TensorShape([64, 50, 64])
 ```
 
 ### PyTorch

From 44303ff8e04e496e0f545d92a60e9758b971e314 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Fri, 31 May 2024 18:45:07 +0530
Subject: [PATCH 09/76] Update Transformers.md

Extended Introduction
---
 contrib/machine-learning/Transformers.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/Transformers.md
index d30bd63..97346bd 100644
--- a/contrib/machine-learning/Transformers.md
+++ b/contrib/machine-learning/Transformers.md
@@ -1,8 +1,9 @@
 # Transformers
 ## Introduction
 A transformer is a deep learning architecture developed by Google and based on the multi-head attention mechanism. It is based on the softmax-based attention 
-mechanism. Before transformers, predecessors of attention mechanism were added to gated recurrent neural networks, such as LSTMs and gated recurrent units (GRUs), which 
-processed datasets sequentially. Dependency on previous token computations prevented them from being able to parallelize the attention mechanism.
+mechanism. Before transformers, predecessors of attention mechanism were added to gated recurrent neural networks, such as LSTMs and gated recurrent units (GRUs), which processed datasets sequentially. Dependency on previous token computations prevented them from being able to parallelize the attention mechanism.
+
+Transformers are a revolutionary approach to natural language processing (NLP). Unlike older models, they excel at understanding long-range connections between words. This "attention" mechanism lets them grasp the context of a sentence, making them powerful for tasks like machine translation, text summarization, and question answering. Introduced in 2017, transformers are now the backbone of many large language models, including tools you might use every day. Their ability to handle complex relationships in language is fueling advancements in AI across various fields.
 
 ## Model Architecture
 <p align="center"><img src="https://github.com/SAM-DEV007/learn-python/assets/60264918/c290ed33-46ff-4b80-8212-47cfe7fbceb3" alt="Model Architecture" /></p>

From f75b2bab640e8b52e94d383ad2805ef487d2984a Mon Sep 17 00:00:00 2001
From: Arihant Yadav <147732947+arihunter-18@users.noreply.github.com>
Date: Fri, 31 May 2024 22:22:54 +0530
Subject: [PATCH 10/76] Add files via upload

---
 contrib/advanced-python/closures.md | 101 ++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 contrib/advanced-python/closures.md

diff --git a/contrib/advanced-python/closures.md b/contrib/advanced-python/closures.md
new file mode 100644
index 0000000..87ad058
--- /dev/null
+++ b/contrib/advanced-python/closures.md
@@ -0,0 +1,101 @@
+# Closures
+In order to have complete understanding of this topic in python, one needs to be crystal clear with the concept of functions and the different types of them which are namely First Class Functions and Nested Functions.
+
+### First Class Functions
+These are the normal functions used by the programmer in routine as they can be assigned to variables, passed as arguments and returned from other functions.
+### Nested Functions
+These are the functions defined within other functions and involve thorough usage of **Closures**. It is also referred as **Inner Functions** by some books. There are times when it is required to prevent a function or the data it has access to from being accessed from other parts of the code, and this is where Nested Functions come into play. Basically, its usage allows the encapsulation of that particular data/function within another function. This enables it to be virtually hidden from the global scope.
+
+## Defining Closures
+In nested functions, if the outer function basically ends up returning the inner function, in this case the concept of closures comes into play.
+
+A closure is a function object that remembers values in enclosing scopes even if they are not present in memory. There are certain neccesary condtions required to create a closure in python :
+1. The inner function must be defined inside the outer function.
+2. The inner function must refer to a value defined in the outer function.
+3. The inner function must return a value.
+
+## Advantages of Closures
+* Closures make it possible to pass data to inner functions without first passing them to outer functions
+* Closures can be used to create private variables and functions
+* They also make it possible to invoke the inner function from outside of the encapsulating outer function.
+* It improves code readability and maintainability
+
+## Examples implementing Closures
+### Example 1 : Basic Implementation
+```python
+def make_multiplier_of(n):
+    def multiplier(x):
+        return x * n
+    return multiplier
+
+times3 = make_multiplier_of(3)
+times5 = make_multiplier_of(5)
+
+print(times3(9))
+print(times5(3))
+```
+#### Output:
+```
+27
+15
+```
+The **multiplier function** is defined inside the **make_multiplier_of function**. It has access to the n variable from the outer scope, even after the make_multiplier_of function has returned. This is an example of a closure.
+
+### Example 2 : Implementation with Decorators
+```python
+def decorator_function(original_function):
+    def wrapper_function(*args, **kwargs):
+        print(f"Wrapper executed before {original_function.__name__}")
+        return original_function(*args, **kwargs)
+    return wrapper_function
+
+@decorator_function
+def display():
+    print("Display function executed")
+
+display()
+```
+#### Output:  
+```
+ Wrapper executed before display
+ Display function executed
+```
+The code in the example defines a decorator function: ***decorator_function*** that takes a function as an argument and returns a new function **wrapper_function**. The **wrapper_function** function prints a message to the console before calling the original function which appends the name of the called function as specified in the code.
+
+The **@decorator_function** syntax is used to apply the decorator_function decorator to the display function. This means that the display function is replaced with the result of calling **decorator_function(display)**.
+
+When the **display()** function is called, the wrapper_function function is executed instead. The wrapper_function function prints a message to the console and then calls the original display function.
+### Example 3 : Implementation with for loop
+```python
+def create_closures():
+    closures = []
+    for i in range(5):
+        def closure(i=i):  # Capture current value of i by default argument
+            return i
+        closures.append(closure)
+    return closures
+
+my_closures = create_closures()
+for closure in my_closures:
+    print(closure())
+
+```
+#### Output:
+```
+0
+1
+2
+3
+4
+```
+The code in the example defines a function **create_closures** that creates a list of closure functions. Each closure function returns the current value of the loop variable i.
+
+The closure function is defined inside the **create_closures function**. It has access to the i variable from the **outer scope**, even after the create_closures function has returned. This is an example of a closure.
+
+The **i**=*i* argument in the closure function is used to capture the current value of *i* by default argument. This is necessary because the ****i** variable in the outer scope is a loop variable, and its value changes in each iteration of the loop. By capturing the current value of *i* in the default argument, we ensure that each closure function returns the correct value of **i**. This is responsible for the generation of output 0,1,2,3,4.
+
+
+For more examples related to closures, [click here](https://dev.to/bshadmehr/understanding-closures-in-python-a-comprehensive-tutorial-11ld).
+
+## Summary
+Closures in Python provide a powerful mechanism for encapsulating state and behavior, enabling more flexible and modular code. Understanding and effectively using closures enables the creation of function factories, allows functions to have state, and facilitates functional programming techniques.
\ No newline at end of file

From 50f1e2c3deb4d244b052fcc4c9e4b7d3b6836551 Mon Sep 17 00:00:00 2001
From: Arihant Yadav <147732947+arihunter-18@users.noreply.github.com>
Date: Fri, 31 May 2024 22:24:16 +0530
Subject: [PATCH 11/76] Updated index.md

---
 contrib/advanced-python/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index b95e4b9..d9a9056 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -7,3 +7,4 @@
 - [Regular Expressions in Python](regular_expressions.md)
 - [JSON module](json-module.md)
 - [Map Function](map-function.md)
+- [Closures](closures.md)

From f65c949564f003591c746088bf8c25be44a65853 Mon Sep 17 00:00:00 2001
From: Ritesh <universe7565@gmail.com>
Date: Sun, 2 Jun 2024 09:17:22 +0530
Subject: [PATCH 12/76] Create hierarchical-clustering.md

---
 .../hierarchical-clustering.md                | 119 ++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 contrib/machine-learning/hierarchical-clustering.md

diff --git a/contrib/machine-learning/hierarchical-clustering.md b/contrib/machine-learning/hierarchical-clustering.md
new file mode 100644
index 0000000..3f9e606
--- /dev/null
+++ b/contrib/machine-learning/hierarchical-clustering.md
@@ -0,0 +1,119 @@
+# Hierarchical Clustering
+
+Hierarchical Clustering is a method of cluster analysis that seeks to build a hierarchy of clusters. This README provides an overview of the hierarchical clustering algorithm, including its fundamental concepts, types, steps, and how to implement it using Python.
+
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Concepts](#concepts)
+3. [Types of Hierarchical Clustering](#types-of-hierarchical-clustering)
+4. [Steps in Hierarchical Clustering](#steps-in-hierarchical-clustering)
+5. [Linkage Criteria](#linkage-criteria)
+6. [Implementation](#implementation)
+    - [Using Scikit-learn](#using-scikit-learn)
+    - [Code Example](#code-example)
+7. [Evaluation Metrics](#evaluation-metrics)
+8. [Conclusion](#conclusion)
+9. [References](#references)
+
+## Introduction
+
+Hierarchical Clustering is an unsupervised learning method used to group similar objects into clusters. Unlike other clustering techniques, hierarchical clustering does not require the number of clusters to be specified beforehand. It produces a tree-like structure called a dendrogram, which displays the arrangement of the clusters and their sub-clusters.
+
+## Concepts
+
+### Dendrogram
+
+A dendrogram is a tree-like diagram that records the sequences of merges or splits. It is a useful tool for visualizing the process of hierarchical clustering.
+
+### Distance Measure
+
+Distance measures are used to quantify the similarity or dissimilarity between data points. Common distance measures include Euclidean distance, Manhattan distance, and cosine similarity.
+
+### Linkage Criteria
+
+Linkage criteria determine how the distance between clusters is calculated. Different linkage criteria include single linkage, complete linkage, average linkage, and Ward's linkage.
+
+## Types of Hierarchical Clustering
+
+1. **Agglomerative Clustering (Bottom-Up Approach)**: 
+    - Starts with each data point as a separate cluster.
+    - Repeatedly merges the closest pairs of clusters until only one cluster remains or a stopping criterion is met.
+
+2. **Divisive Clustering (Top-Down Approach)**: 
+    - Starts with all data points in a single cluster.
+    - Repeatedly splits clusters into smaller clusters until each data point is its own cluster or a stopping criterion is met.
+
+## Steps in Hierarchical Clustering
+
+1. **Calculate Distance Matrix**: Compute the distance between each pair of data points.
+2. **Create Clusters**: Treat each data point as a single cluster.
+3. **Merge Closest Clusters**: Find the two clusters that are closest to each other and merge them into a single cluster.
+4. **Update Distance Matrix**: Update the distance matrix to reflect the distance between the new cluster and the remaining clusters.
+5. **Repeat**: Repeat steps 3 and 4 until all data points are merged into a single cluster or the desired number of clusters is achieved.
+
+## Linkage Criteria
+
+1. **Single Linkage (Minimum Linkage)**: The distance between two clusters is defined as the minimum distance between any single data point in the first cluster and any single data point in the second cluster.
+2. **Complete Linkage (Maximum Linkage)**: The distance between two clusters is defined as the maximum distance between any single data point in the first cluster and any single data point in the second cluster.
+3. **Average Linkage**: The distance between two clusters is defined as the average distance between all pairs of data points, one from each cluster.
+4. **Ward's Linkage**: The distance between two clusters is defined as the increase in the sum of squared deviations from the mean when the two clusters are merged.
+
+## Implementation
+
+### Using Scikit-learn
+
+Scikit-learn is a popular machine learning library in Python that provides tools for hierarchical clustering.
+
+### Code Example
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.cluster.hierarchy import dendrogram, linkage
+from sklearn.cluster import AgglomerativeClustering
+from sklearn.preprocessing import StandardScaler
+
+# Load dataset
+data = pd.read_csv('path/to/your/dataset.csv')
+
+# Preprocess the data
+scaler = StandardScaler()
+data_scaled = scaler.fit_transform(data)
+
+# Perform hierarchical clustering
+Z = linkage(data_scaled, method='ward')
+
+# Plot the dendrogram
+plt.figure(figsize=(10, 7))
+dendrogram(Z)
+plt.title('Dendrogram')
+plt.xlabel('Data Points')
+plt.ylabel('Distance')
+plt.show()
+
+# Perform Agglomerative Clustering
+agg_clustering = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')
+labels = agg_clustering.fit_predict(data_scaled)
+
+# Add cluster labels to the original data
+data['Cluster'] = labels
+print(data.head())
+```
+
+## Evaluation Metrics
+
+- **Silhouette Score**: Measures how similar a data point is to its own cluster compared to other clusters.
+- **Cophenetic Correlation Coefficient**: Measures how faithfully a dendrogram preserves the pairwise distances between the original data points.
+- **Dunn Index**: Ratio of the minimum inter-cluster distance to the maximum intra-cluster distance.
+
+## Conclusion
+
+Hierarchical clustering is a versatile and intuitive method for clustering data. It is particularly useful when the number of clusters is not known beforehand. By understanding the different linkage criteria and evaluation metrics, one can effectively apply hierarchical clustering to various types of data.
+
+## References
+
+- [Scikit-learn Documentation](https://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering)
+- [Wikipedia: Hierarchical Clustering](https://en.wikipedia.org/wiki/Hierarchical_clustering)
+- [Towards Data Science: Hierarchical Clustering Explained](https://towardsdatascience.com/hierarchical-clustering-explained-925d9e1600c1)

From 5b6cd66f79e2cc0341f94bd0ec3ee935ccf8a20c Mon Sep 17 00:00:00 2001
From: Ritesh <universe7565@gmail.com>
Date: Sun, 2 Jun 2024 09:21:45 +0530
Subject: [PATCH 13/76] Update index.md

---
 contrib/machine-learning/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index b6945cd..20305dc 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -15,4 +15,5 @@
 - [Logistic Regression](logistic-regression.md)
 - [Types_of_Cost_Functions](cost-functions.md)
 - [Clustering](clustering.md)
+- [Hierarchical Clustering](hierarchical-clustering.md)
 - [Grid Search](grid-search.md)

From 8ef6a2febc2ec303ffdc0702d838e2caa1462b17 Mon Sep 17 00:00:00 2001
From: Soubeer Koley <soubeer011@gmail.com>
Date: Sun, 2 Jun 2024 09:27:46 +0530
Subject: [PATCH 14/76] added ensemble learning

---
 contrib/machine-learning/ensemble_learning.md | 140 ++++++++++++++++++
 contrib/machine-learning/index.md             |   3 +-
 2 files changed, 142 insertions(+), 1 deletion(-)
 create mode 100644 contrib/machine-learning/ensemble_learning.md

diff --git a/contrib/machine-learning/ensemble_learning.md b/contrib/machine-learning/ensemble_learning.md
new file mode 100644
index 0000000..940bd09
--- /dev/null
+++ b/contrib/machine-learning/ensemble_learning.md
@@ -0,0 +1,140 @@
+# Ensemble Learning
+
+Ensemble Learning is a powerful machine learning paradigm that combines multiple models to achieve better performance than any individual model. The idea is to leverage the strengths of different models to improve overall accuracy, robustness, and generalization.
+
+
+
+## Introduction
+
+Ensemble Learning is a technique that combines the predictions from multiple machine learning models to make more accurate and robust predictions than a single model. It leverages the diversity of different models to reduce errors and improve performance.
+
+## Types of Ensemble Learning
+
+### Bagging
+
+Bagging, or Bootstrap Aggregating, involves training multiple versions of the same model on different subsets of the training data and averaging their predictions. The most common example of bagging is the `RandomForest` algorithm.
+
+### Boosting
+
+Boosting focuses on training models sequentially, where each new model corrects the errors made by the previous ones. This way, the ensemble learns from its mistakes, leading to improved performance. `AdaBoost` and `Gradient Boosting` are popular examples of boosting algorithms.
+
+### Stacking
+
+Stacking involves training multiple models (the base learners) and a meta-model that combines their predictions. The base learners are trained on the original dataset, while the meta-model is trained on the outputs of the base learners. This approach allows leveraging the strengths of different models.
+
+## Advantages and Disadvantages
+
+### Advantages
+
+- **Improved Accuracy**: Combines the strengths of multiple models.
+- **Robustness**: Reduces the risk of overfitting and model bias.
+- **Versatility**: Can be applied to various machine learning tasks, including classification and regression.
+
+### Disadvantages
+
+- **Complexity**: More complex than individual models, making interpretation harder.
+- **Computational Cost**: Requires more computational resources and training time.
+- **Implementation**: Can be challenging to implement and tune effectively.
+
+## Key Concepts
+
+- **Diversity**: The models in the ensemble should be diverse to benefit from their different strengths.
+- **Voting/Averaging**: For classification, majority voting is used to combine predictions. For regression, averaging is used.
+- **Weighting**: In some ensembles, models are weighted based on their accuracy or other metrics.
+
+## Code Examples
+
+### Bagging with Random Forest
+
+Below is an example of using Random Forest for classification on the Iris dataset.
+
+```python
+import numpy as np
+import pandas as pd
+from sklearn.datasets import load_iris
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, classification_report
+
+# Load dataset
+iris = load_iris()
+X, y = iris.data, iris.target
+
+# Split dataset
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Initialize Random Forest model
+clf = RandomForestClassifier(n_estimators=100, random_state=42)
+
+# Train the model
+clf.fit(X_train, y_train)
+
+# Make predictions
+y_pred = clf.predict(X_test)
+
+# Evaluate the model
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy * 100:.2f}%")
+print("Classification Report:\n", classification_report(y_test, y_pred))
+```
+
+### Boosting with AdaBoost
+Below is an example of using AdaBoost for classification on the Iris dataset.
+
+```
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.tree import DecisionTreeClassifier
+
+# Initialize base model
+base_model = DecisionTreeClassifier(max_depth=1)
+
+# Initialize AdaBoost model
+ada_clf = AdaBoostClassifier(base_estimator=base_model, n_estimators=50, random_state=42)
+
+# Train the model
+ada_clf.fit(X_train, y_train)
+
+# Make predictions
+y_pred = ada_clf.predict(X_test)
+
+# Evaluate the model
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy * 100:.2f}%")
+print("Classification Report:\n", classification_report(y_test, y_pred))
+```
+
+### Stacking with Multiple Models
+Below is an example of using stacking with multiple models for classification on the Iris dataset.
+
+```
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.ensemble import StackingClassifier
+
+# Define base models
+base_models = [
+    ('knn', KNeighborsClassifier(n_neighbors=5)),
+    ('svc', SVC(kernel='linear', probability=True))
+]
+
+# Define meta-model
+meta_model = LogisticRegression()
+
+# Initialize Stacking model
+stacking_clf = StackingClassifier(estimators=base_models, final_estimator=meta_model, cv=5)
+
+# Train the model
+stacking_clf.fit(X_train, y_train)
+
+# Make predictions
+y_pred = stacking_clf.predict(X_test)
+
+# Evaluate the model
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy * 100:.2f}%")
+print("Classification Report:\n", classification_report(y_test, y_pred))
+```
+
+## Conclusion
+Ensemble Learning is a powerful technique that combines multiple models to improve overall performance. By leveraging the strengths of different models, it provides better accuracy, robustness, and generalization. However, it comes with increased complexity and computational cost. Understanding and implementing ensemble methods can significantly enhance machine learning solutions.
\ No newline at end of file
diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index 073bca9..a46cd7a 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -9,4 +9,5 @@
 - [TensorFlow.md](tensorFlow.md)
 - [PyTorch.md](pytorch.md)
 - [Types of optimizers](Types_of_optimizers.md)
-- [Random Forest](Random_Forest.md)
\ No newline at end of file
+- [Random Forest](Random_Forest.md)
+- [Ensemble Learning](ensemble_learning.md)
\ No newline at end of file

From 402289d3ceae6add26458f41d33364eff322f8e2 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Sun, 2 Jun 2024 10:23:09 +0530
Subject: [PATCH 15/76] Rename Transformers.md to transformers.md

---
 contrib/machine-learning/{Transformers.md => transformers.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/machine-learning/{Transformers.md => transformers.md} (100%)

diff --git a/contrib/machine-learning/Transformers.md b/contrib/machine-learning/transformers.md
similarity index 100%
rename from contrib/machine-learning/Transformers.md
rename to contrib/machine-learning/transformers.md

From e13fb234f2829a1b918aac3c044e4feef5066d34 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Sun, 2 Jun 2024 10:23:56 +0530
Subject: [PATCH 16/76] Add transformers.md

---
 contrib/machine-learning/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index b6945cd..13d9440 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -16,3 +16,4 @@
 - [Types_of_Cost_Functions](cost-functions.md)
 - [Clustering](clustering.md)
 - [Grid Search](grid-search.md)
+- [Transformers](transformers.md)

From 229458043245de432c96f05457dd79330d568a92 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Sun, 2 Jun 2024 10:39:37 +0530
Subject: [PATCH 17/76] Update transformers.md

Added source for the image
---
 contrib/machine-learning/transformers.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 97346bd..9fbfa6d 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -6,7 +6,10 @@ mechanism. Before transformers, predecessors of attention mechanism were added t
 Transformers are a revolutionary approach to natural language processing (NLP). Unlike older models, they excel at understanding long-range connections between words. This "attention" mechanism lets them grasp the context of a sentence, making them powerful for tasks like machine translation, text summarization, and question answering. Introduced in 2017, transformers are now the backbone of many large language models, including tools you might use every day. Their ability to handle complex relationships in language is fueling advancements in AI across various fields.
 
 ## Model Architecture
-<p align="center"><img src="https://github.com/SAM-DEV007/learn-python/assets/60264918/c290ed33-46ff-4b80-8212-47cfe7fbceb3" alt="Model Architecture" /></p>
+<p align="center">
+    <img src="https://github.com/SAM-DEV007/learn-python/assets/60264918/c290ed33-46ff-4b80-8212-47cfe7fbceb3" alt="Model Architecture" /><br>
+Source: <a href="https://arxiv.org/pdf/1706.03762">Attention Is All You Need</a> - Figure 1
+</p>
 
 ### Encoder
 The encoder is composed of a stack of identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, positionwise fully connected feed-forward network. Each encoder consists of two major components: a self-attention mechanism and a feed-forward neural network. The self-attention mechanism accepts input encodings from the previous encoder and weights their relevance to each other to generate output encodings. The feed-forward neural network further processes each output encoding individually. These output encodings are then passed to the next encoder as its input, as well as to the decoders.

From 07a1e737606d10d7e96e2291cec21003309bfbf0 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Sun, 2 Jun 2024 10:46:21 +0530
Subject: [PATCH 18/76] Update transformers.md

Added bibliography
---
 contrib/machine-learning/transformers.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 9fbfa6d..0799b7f 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -430,4 +430,11 @@ These may include:
 - Text generation
 - Biological sequence analysis
 - Computer code generation
-- Video analysis
+
+## Bibliography
+- [Attention Is All You Need](https://arxiv.org/pdf/1706.03762)
+- [Tensorflow Tutorial](https://www.tensorflow.org/text/tutorials/transformer)
+- [Tensorflow Models Docs](https://www.tensorflow.org/api_docs/python/tfm/nlp/layers)
+- [Wikipedia](https://en.wikipedia.org/wiki/Transformer_(deep_learning_architecture))
+- [HuggingFace](https://huggingface.co/docs/transformers/en/index)
+- [PyTorch](https://pytorch.org/docs/stable/generated/torch.nn.Transformer.html)

From 643cadfa330d4fa5443ba1f4044ecc5942e2b7f3 Mon Sep 17 00:00:00 2001
From: manishh12 <manishdid360@gmail.com>
Date: Sun, 2 Jun 2024 11:54:06 +0530
Subject: [PATCH 19/76] Added Generators under Advance python

---
 contrib/advanced-python/Generators.md | 87 +++++++++++++++++++++++++++
 contrib/advanced-python/index.md      |  1 +
 2 files changed, 88 insertions(+)
 create mode 100644 contrib/advanced-python/Generators.md

diff --git a/contrib/advanced-python/Generators.md b/contrib/advanced-python/Generators.md
new file mode 100644
index 0000000..ff5226e
--- /dev/null
+++ b/contrib/advanced-python/Generators.md
@@ -0,0 +1,87 @@
+# Generators Under Advanced Python
+
+## Introduction
+
+Generators in Python are a sophisticated feature that enables the creation of iterators without the need to construct a full list in memory. They allow you to generate values on-the-fly, which is particularly beneficial for working with large datasets or infinite sequences. In this README, we'll explore generators in depth, covering their types, mathematical formulation, advantages, disadvantages, and implementation examples.
+
+## Function Generators
+
+Function generators are created using the `yield` keyword within a function. When invoked, a function generator returns a generator iterator, allowing you to iterate over the values generated by the function.
+
+### Mathematical Formulation
+
+Function generators can be represented mathematically using set-builder notation. The general form is:
+
+```
+{expression | variable in iterable, condition}
+```
+
+Where:
+- `expression` is the expression to generate values.
+- `variable` is the variable used in the expression.
+- `iterable` is the sequence of values to iterate over.
+- `condition` is an optional condition that filters the values.
+
+### Advantages of Function Generators
+
+1. **Memory Efficiency**: Function generators produce values lazily, meaning they generate values only when needed, saving memory compared to constructing an entire sequence upfront.
+
+2. **Lazy Evaluation**: Values are generated on-the-fly as they are consumed, leading to improved performance and reduced overhead, especially when dealing with large datasets.
+
+3. **Infinite Sequences**: Function generators can represent infinite sequences, such as the Fibonacci sequence, allowing you to work with data streams of arbitrary length without consuming excessive memory.
+
+### Disadvantages of Function Generators
+
+1. **Single Iteration**: Once a function generator is exhausted, it cannot be reused. If you need to iterate over the sequence again, you'll have to create a new generator.
+
+2. **Limited Random Access**: Function generators do not support random access like lists. They only allow sequential access, which might be a limitation depending on the use case.
+
+### Implementation Example
+
+```python
+def fibonacci():
+    a, b = 0, 1
+    while True:
+        yield a
+        a, b = b, a + b
+
+# Usage
+fib_gen = fibonacci()
+for _ in range(10):
+    print(next(fib_gen))
+```
+
+## Generator Expressions
+
+Generator expressions are similar to list comprehensions but return a generator object instead of a list. They offer a concise way to create generators without the need for a separate function.
+
+### Mathematical Formulation
+
+Generator expressions can also be represented mathematically using set-builder notation. The general form is the same as for function generators.
+
+### Advantages of Generator Expressions
+
+1. **Memory Efficiency**: Generator expressions produce values lazily, similar to function generators, resulting in memory savings.
+
+2. **Lazy Evaluation**: Values are generated on-the-fly as they are consumed, providing improved performance and reduced overhead.
+
+### Disadvantages of Generator Expressions
+
+1. **Single Iteration**: Like function generators, once a generator expression is exhausted, it cannot be reused.
+
+2. **Limited Random Access**: Generator expressions, similar to function generators, do not support random access.
+
+### Implementation Example
+
+```python
+# Generate squares of numbers from 0 to 9
+square_gen = (x**2 for x in range(10))
+
+# Usage
+for num in square_gen:
+    print(num)
+```
+
+## Conclusion
+
+Generators offer a powerful mechanism for creating iterators efficiently in Python. By understanding the differences between function generators and generator expressions, along with their mathematical formulation, advantages, and disadvantages, you can leverage them effectively in various scenarios. Whether you're dealing with large datasets or need to work with infinite sequences, generators provide a memory-efficient solution with lazy evaluation capabilities, contributing to more elegant and scalable code.
\ No newline at end of file
diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index fa2fd7b..df4b545 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -9,3 +9,4 @@
 - [Map Function](map-function.md)
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
+- [Generators](Generators.md)

From 3e35783d59919de603e6d11e81df54fdf47662b2 Mon Sep 17 00:00:00 2001
From: SAM <8dmasters@gmail.com>
Date: Sun, 2 Jun 2024 16:19:11 +0530
Subject: [PATCH 20/76] Create transformer-architecture.png

---
 .../assets/transformer-architecture.png         | Bin 0 -> 57018 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 contrib/machine-learning/assets/transformer-architecture.png

diff --git a/contrib/machine-learning/assets/transformer-architecture.png b/contrib/machine-learning/assets/transformer-architecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..2854ab0a8d3e6f0ba0c53735afb57e81eb825a3f
GIT binary patch
literal 57018
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

literal 0
HcmV?d00001


From 5e4308e7f0173d1448e984bdd4dc24053012a90b Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Sun, 2 Jun 2024 16:22:50 +0530
Subject: [PATCH 21/76] Update transformers.md

Added image location
---
 contrib/machine-learning/transformers.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 0799b7f..0dcf697 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -7,7 +7,7 @@ Transformers are a revolutionary approach to natural language processing (NLP).
 
 ## Model Architecture
 <p align="center">
-    <img src="https://github.com/SAM-DEV007/learn-python/assets/60264918/c290ed33-46ff-4b80-8212-47cfe7fbceb3" alt="Model Architecture" /><br>
+    <img src="assets/transformer-architecture.png" alt="Model Architecture" /><br>
 Source: <a href="https://arxiv.org/pdf/1706.03762">Attention Is All You Need</a> - Figure 1
 </p>
 

From f84da4252f1a80405a98451389d70c0ec2d1d3e0 Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Sun, 2 Jun 2024 21:39:17 +0530
Subject: [PATCH 22/76] Rename OOPs.md to oops.md

---
 contrib/advanced-python/{OOPs.md => oops.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/advanced-python/{OOPs.md => oops.md} (100%)

diff --git a/contrib/advanced-python/OOPs.md b/contrib/advanced-python/oops.md
similarity index 100%
rename from contrib/advanced-python/OOPs.md
rename to contrib/advanced-python/oops.md

From 18003e05e2d9c9f019601c0bddd89e7eab456d90 Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Sun, 2 Jun 2024 21:39:35 +0530
Subject: [PATCH 23/76] Update index.md

---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index fa2fd7b..16210c2 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -1,6 +1,6 @@
 # List of sections
 
-- [OOPs](OOPs.md)
+- [OOPs](oops.md)
 - [Decorators/\*args/**kwargs](decorator-kwargs-args.md)
 - [Lambda Function](lambda-function.md)
 - [Working with Dates & Times in Python](dates_and_times.md)

From 20494f222f48f91209a112475961cde7d1f01175 Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Sun, 2 Jun 2024 21:47:03 +0530
Subject: [PATCH 24/76] Update index.md

---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index df4b545..0ce294f 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -9,4 +9,4 @@
 - [Map Function](map-function.md)
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
-- [Generators](Generators.md)
+- [Generators](generators.md)

From bb245f09792e9853a7545503d56bcb027754ac19 Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Sun, 2 Jun 2024 21:48:10 +0530
Subject: [PATCH 25/76] Update and rename Generators.md to generators.md

---
 contrib/advanced-python/{Generators.md => generators.md} | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
 rename contrib/advanced-python/{Generators.md => generators.md} (94%)

diff --git a/contrib/advanced-python/Generators.md b/contrib/advanced-python/generators.md
similarity index 94%
rename from contrib/advanced-python/Generators.md
rename to contrib/advanced-python/generators.md
index ff5226e..96287ef 100644
--- a/contrib/advanced-python/Generators.md
+++ b/contrib/advanced-python/generators.md
@@ -1,8 +1,8 @@
-# Generators Under Advanced Python
+# Generators
 
 ## Introduction
 
-Generators in Python are a sophisticated feature that enables the creation of iterators without the need to construct a full list in memory. They allow you to generate values on-the-fly, which is particularly beneficial for working with large datasets or infinite sequences. In this README, we'll explore generators in depth, covering their types, mathematical formulation, advantages, disadvantages, and implementation examples.
+Generators in Python are a sophisticated feature that enables the creation of iterators without the need to construct a full list in memory. They allow you to generate values on-the-fly, which is particularly beneficial for working with large datasets or infinite sequences. We will explore generators in depth, covering their types, mathematical formulation, advantages, disadvantages, and implementation examples.
 
 ## Function Generators
 
@@ -84,4 +84,4 @@ for num in square_gen:
 
 ## Conclusion
 
-Generators offer a powerful mechanism for creating iterators efficiently in Python. By understanding the differences between function generators and generator expressions, along with their mathematical formulation, advantages, and disadvantages, you can leverage them effectively in various scenarios. Whether you're dealing with large datasets or need to work with infinite sequences, generators provide a memory-efficient solution with lazy evaluation capabilities, contributing to more elegant and scalable code.
\ No newline at end of file
+Generators offer a powerful mechanism for creating iterators efficiently in Python. By understanding the differences between function generators and generator expressions, along with their mathematical formulation, advantages, and disadvantages, you can leverage them effectively in various scenarios. Whether you're dealing with large datasets or need to work with infinite sequences, generators provide a memory-efficient solution with lazy evaluation capabilities, contributing to more elegant and scalable code.

From 843eb9b01959f199b6bba37ac3839356c3023f6d Mon Sep 17 00:00:00 2001
From: anamika123 <anamika23428@gmail.com>
Date: Sun, 2 Jun 2024 22:04:58 +0530
Subject: [PATCH 26/76] eval function

---
 contrib/advanced-python/eval_function.md | 75 ++++++++++++++++++++++++
 contrib/advanced-python/index.md         |  1 +
 2 files changed, 76 insertions(+)
 create mode 100644 contrib/advanced-python/eval_function.md

diff --git a/contrib/advanced-python/eval_function.md b/contrib/advanced-python/eval_function.md
new file mode 100644
index 0000000..9e3ec54
--- /dev/null
+++ b/contrib/advanced-python/eval_function.md
@@ -0,0 +1,75 @@
+# Understanding the `eval` Function in Python
+## Introduction
+
+The `eval` function in Python allows you to execute a string-based Python expression dynamically.  This can be useful in various scenarios where you need to evaluate expressions that are not known until runtime.
+
+## Syntax
+```python 
+eval(expression, globals=None, locals=None)
+```
+
+### Parameters:
+
+* expression: String is parsed and evaluated as a Python expression
+* globals [optional]: Dictionary to specify the available global methods and variables.
+* locals [optional]: Another dictionary to specify the available local methods and variables.
+
+## Examples
+Example 1:
+```python
+result = eval('2 + 3 * 4')
+print(result)  # Output: 14
+```
+Example 2:
+
+```python
+x = 10
+expression = 'x * 2'
+result = eval(expression, {'x': x})
+print(result)  # Output: 20
+```
+Example 3:
+```python
+x = 10
+def multiply(a, b):
+    return a * b
+expression = 'multiply(x, 5) + 2'
+result = eval(expression)
+print("Result:",result)  # Output: Result:52
+```
+Example 4:
+```python
+expression = input("Enter a Python expression: ")
+result = eval(expression)
+print("Result:", result)
+#input= "3+2"
+#Output: Result:5
+```
+
+Example 5:
+```python
+import numpy as np
+a=np.random.randint(1,9)
+b=np.random.randint(1,9)
+operations=["*","-","+"]
+op=np.random.choice(operations)
+
+expression=str(a)+op+str(b)
+correct_answer=eval(expression)
+given_answer=int(input(str(a)+" "+op+" "+str(b)+" = "))
+
+if given_answer==correct_answer:
+    print("Correct")
+else:
+    print("Incorrect")
+    print("correct answer is :" ,correct_answer)
+
+#2 * 1 = 8
+#Incorrect
+#correct answer is : 2
+#or
+#3 * 2 = 6
+#Correct
+```
+## Conclusion
+The eval function is a powerful tool in Python that allows for dynamic evaluation of expressions.
\ No newline at end of file
diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index b31544e..9419480 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,3 +10,4 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
+- [Eval Function](eval_function.md)

From ea37cbb25457eaf0c650cd6822ff62fdb63da3a9 Mon Sep 17 00:00:00 2001
From: Lingamuneni Santhosh Siddhardha
 <103999924+Santhosh-Siddhardha@users.noreply.github.com>
Date: Sun, 2 Jun 2024 22:07:01 +0530
Subject: [PATCH 27/76] Create list_comprehension.md

Added Introduction
Added Syntax
Added Examples
Added Conclusion
---
 contrib/advanced-python/list_comprehension.md | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 contrib/advanced-python/list_comprehension.md

diff --git a/contrib/advanced-python/list_comprehension.md b/contrib/advanced-python/list_comprehension.md
new file mode 100644
index 0000000..d9ab589
--- /dev/null
+++ b/contrib/advanced-python/list_comprehension.md
@@ -0,0 +1,73 @@
+# List Comprehension
+
+Creating lists concisely and expressively is what list comprehension in Python does. You can generate lists from already existing iterables like lists, tuples or strings with a short form. 
+This boosts the readability of code and reduces necessity of using explicit looping constructs.
+
+## Syntax :
+
+### Basic syntax
+
+```python
+new_list = [expression for item in iterable]
+```
+- **new_list**: This is the name given to the list that will be created using the list comprehension.
+- **expression**: This is the expression that defines how each element of the new list will be generated or transformed.
+- **item**: This variable represents each individual element from the iterable. It takes on the value of each element in the iterable during each iteration.
+- **iterable**: This is the sequence-like object over which the iteration will take place. It provides the elements that will be processed by the expression.
+
+This list comprehension syntax `[expression for item in iterable]` allows you to generate a new list by applying a specific expression to each element in an iterable.
+
+### Syntax including condition
+
+```python
+new_list = [expression for item in iterable if condition]
+```
+- **new_list**: This is the name given to the list that will be created using the list comprehension.
+- **expression**: This is the expression that defines how each element of the new list will be generated or transformed.
+- **item**: This variable represents each individual element from the iterable. It takes on the value of each element in the iterable during each iteration.
+- **iterable**: This is the sequence-like object over which the iteration will take place. It provides the elements that will be processed by the expression.
+- **if condition**: This is an optional part of the syntax. It allows for conditional filtering of elements from the iterable. Only items that satisfy the condition
+ will be included in the new list.
+
+
+## Examples:
+
+1. Generating a list of squares of numbers from 1 to 5:
+   
+```python
+squares = [x ** 2 for x in range(1, 6)]
+print(squares)
+```
+
+- **Output** :
+```python
+[1, 4, 9, 16, 25]
+```
+
+2. Filtering even numbers from a list:
+   
+```python
+nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+even = [x for x in nums if x % 2 == 0]
+print(even)
+```
+
+- **Output** :
+```python
+[2, 4, 6, 8, 10]
+```
+
+3. Flattening a list of lists:
+```python
+matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+flat = [x for sublist in matrix for x in sublist]
+print(flat)
+```
+
+- **Output** :
+```python
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+List comprehension is a powerful feature in Python for creating lists based on existing iterables with a concise syntax. 
+By mastering list comprehension, developers can write cleaner, more expressive code and leverage Python's functional programming capabilities effectively.

From b1f8d147a2abd103e4029c4e366011c1831fe784 Mon Sep 17 00:00:00 2001
From: Lingamuneni Santhosh Siddhardha
 <103999924+Santhosh-Siddhardha@users.noreply.github.com>
Date: Sun, 2 Jun 2024 22:08:52 +0530
Subject: [PATCH 28/76] Update index.md

Added List Comprehension section
---
 contrib/advanced-python/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index b31544e..7ae2ede 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,3 +10,4 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
+- [List Comprehension](#list_comprehension.md)

From 53efed98073fba08e3c2867676273f654882c9cb Mon Sep 17 00:00:00 2001
From: Lingamuneni Santhosh Siddhardha
 <103999924+Santhosh-Siddhardha@users.noreply.github.com>
Date: Sun, 2 Jun 2024 22:11:33 +0530
Subject: [PATCH 29/76] Update index.md

made a small change
---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index 7ae2ede..631423a 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,4 +10,4 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
-- [List Comprehension](#list_comprehension.md)
+- [List Comprehension](list_comprehension.md)

From 0f0d58ce2dc3b013c9e0a12561e7208ff58cf93a Mon Sep 17 00:00:00 2001
From: Dishika Vaishkiyar <152963337+Dishika18@users.noreply.github.com>
Date: Tue, 4 Jun 2024 00:18:27 +0530
Subject: [PATCH 30/76] Added Content: Scatter Chart in Matplotlib

---
 .../images/img_colorbar.png                     | Bin 0 -> 2386 bytes
 .../images/scatter_color.png                    | Bin 0 -> 12534 bytes
 .../images/scatter_coloreachdot.png             | Bin 0 -> 12330 bytes
 .../images/scatter_colormap1.png                | Bin 0 -> 12824 bytes
 .../images/scatter_colormap2.png                | Bin 0 -> 17457 bytes
 .../images/scatter_compare.png                  | Bin 0 -> 12762 bytes
 .../images/simple_scatter.png                   | Bin 0 -> 11079 bytes
 7 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 contrib/plotting-visualization/images/img_colorbar.png
 create mode 100644 contrib/plotting-visualization/images/scatter_color.png
 create mode 100644 contrib/plotting-visualization/images/scatter_coloreachdot.png
 create mode 100644 contrib/plotting-visualization/images/scatter_colormap1.png
 create mode 100644 contrib/plotting-visualization/images/scatter_colormap2.png
 create mode 100644 contrib/plotting-visualization/images/scatter_compare.png
 create mode 100644 contrib/plotting-visualization/images/simple_scatter.png

diff --git a/contrib/plotting-visualization/images/img_colorbar.png b/contrib/plotting-visualization/images/img_colorbar.png
new file mode 100644
index 0000000000000000000000000000000000000000..acc1ec5bd84d52a0f8bb3a9a4fc88405ca6e8edd
GIT binary patch
literal 2386
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
Ef}ylx_y7O^

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/scatter_color.png b/contrib/plotting-visualization/images/scatter_color.png
new file mode 100644
index 0000000000000000000000000000000000000000..17c6ddccd6514cde9d3791407dfc45240c222b58
GIT binary patch
literal 12534
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

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/scatter_coloreachdot.png b/contrib/plotting-visualization/images/scatter_coloreachdot.png
new file mode 100644
index 0000000000000000000000000000000000000000..c6636296e3ac39bd2519e1ff8c93bf79c69a1dee
GIT binary patch
literal 12330
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

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/scatter_colormap1.png b/contrib/plotting-visualization/images/scatter_colormap1.png
new file mode 100644
index 0000000000000000000000000000000000000000..212b368023d9babfbd95dc3e92106512ecb0ef55
GIT binary patch
literal 12824
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
K&%bW==wAT#r?z<j

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/scatter_colormap2.png b/contrib/plotting-visualization/images/scatter_colormap2.png
new file mode 100644
index 0000000000000000000000000000000000000000..08c40cce1ed83cf201cc2a24c49c05177f681fb9
GIT binary patch
literal 17457
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

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/scatter_compare.png b/contrib/plotting-visualization/images/scatter_compare.png
new file mode 100644
index 0000000000000000000000000000000000000000..f94e18be1e01a01fddc48fac5128a76534ada8e0
GIT binary patch
literal 12762
zcmeHt2T&F3wq_GlL{L-|C5tE`QIcd(P}m}%L_wlR&N;(2i%QxgQF4^5<REMefD$C<
zC^;iJ!&|MMd+xb&->o-q?o8E8ja63DyZ`?CPwQLX`quKfp&&y}N==F&2suVpS_wf2
zu?RxYN3s`wIS^Yc1Q%la%NP|B_~$`#_bJ@(w~^JbN03AM=zoGY63M3UqoBi;TMo+B
zMh?#Uc7}+hzJra0wS$G}9Y!ZZJ9|@WD_+hEoEO*`O&lC-gt@r>e9mcYXUs)mM0FBD
z7!i#0B^8&5nO<)PmF39Y`S!b5Vm@Ae7hHHFMf??064f`)q|XnM?!9oc@w|=X=Qc-6
zb#k=>v{#;TN{@${JwH&~t$g!Z-dOi#{a#-qZJ!ZhvLm)1Zh2dNCh_S!Eg1BM_)E_m
zgH+N%3}gA-+1hPUhOt^7`>~*&Rl1;Xs%VkbZCi~{!~HOsO4*zexFF2O2`CVxoSRq@
zZaz^U1PDSVg%BeMH`)Jx@ZVdKrJNG1%JG9w@|@>%42_JcN9;Pa4<g9;o|^2IuC7!`
z#+Y0_-m#A)*krxAzS8Qty1WuH1hF|nO+(|j(rMhS{g?xuG4k>%D-Bb98Jh3VB8Rtq
zZ=6f$>FF8YEcAh=F^jobRYRu`LL}hM^_{iQaF#N3=dS)cb`HjmFzSD#Ynr7_nc<yS
zqGipJy=LF7eGKeE26=dL@}g{rePTl&-g1#RVK7nYQi`V|0is8wK=5fDo_QB?2y9`L
z-mqqudOZ+BpByD*jNs@w9KIgZTK7OEU-jGb7eq)o1+k=H_w1`oUhfO+thp>autZW6
z$af3N=n7|A1UV>)Jj{uVI@)gwmWL2fd<#{lEb3Cvq~BY}T(1!bzn-{{kQmF^%V?I$
zPEr&4_i%YdcwrGFo&q`CdN@CKB))!mjLsdswjQ3Ht?r~$xpBUCA!2yG%4(IEse6Km
z1P-}x%qdK2Piw-0@3I*w{Zp$&ci!B$36d3$b__g>pPf4w@>t&J3|I(r5qpi@7e2+o
zN0(2zmg?+zaLHAazNALTG^FH}!|JPI&d3E}#g~~87phO5g62YF+nXvjq#ZVN`f?*Q
zQ~s@IHQ*9yFMI+)C=hw|?zdc{xpR%|82JxGsg@mKg>eWX8O?-HXC~&2{cz?Pg4>1D
z2sNh&@9E4xZf2Xd*w;%>R+$B{<1b2ujT)cHW=D{QCnVU%_Q^%)u$BBRad~i^&5dGW
zLJ(PgV#zm!4Ot<)SHF(=iq%am8Z{6C?Crbu6<OPu%1TQ}kiI7=$r&a$)t=?=x~1s7
z5tLapN*(Ds8g5sl)%DImCM>$KuP@Vmwn)Y}$~8$rWQH#!G<33AQ9{1u6m#U@WxPOr
z=`}olkw;8unQ43HTTQO(tm;Dv1fe~5hG-y6*DK`!*ZUi6YU$(i^EF&}Eq{p}7k`QP
z^z`dfZ5hq*ET-=D#k7nJ`F3sRNMT{&jnwIcF$H_mTGt1T+gFUytI*5=1S^#|tYi~(
zR=z0#6XfRMF<KjrOMt!#yQ?02i1Au{-9NrQ7Tw;euFHYZ%rWw{v$tQ?-Cfo#9(`p#
zsKX1ZnJxSEWVv#l=cW^#u!HPT7KIm92Z#yJv$Lzn%lrC<fb}eu21gKxs@B!jQFH5I
zzX=Y#csU~^BxGh~H9NoA)!p6N*GFH<K>BDS{VIZB%kB)5=_#_;;A&bI$NJ8nKR>+e
z7GD4sO02dI_L$-7UdibC<Oll>neFauU+BKAsTmv;)I79W7cHUtL66(b+`?jdN(nwY
z`0Wd_RyyaYxV^cmuBxi)a9de9$Z4i4F)l8S9?vBvrcLk9G77sEV5YRdi?y`0-1zb7
zQ2Z(lHFd5*)j>l;L(?w-r@9KPqs7;UkIwX#sN<IU+~+XQYPZ%s#Nn)N|9B$N0$Zz0
zPA_^(Lqo%D;NCvIJD;D9t9}50QwYKFVy(;8ldk&FrUagrxrUp??|S*t3Mu)EE<9y6
z{q&feTF5TptYQ>9=9RExD%wmnP3?+zC71WQT(8Y1^5T)u+Yaj^Vdf1nm%0jV<9n=}
z2M>{ev%9AiYN+8v6_|QCHsHNZ*8LBR$qxt+*~9O>lgG&z(QniLzw2X~>t_jV$i5#m
zb@pvp33qVw3sz@NEQ-tl)6jbk2hC%9xm{IBDNd4+F{~zWd8)li)Jh}tIEQ8eIEZ^h
z`zEW|vRXvu-XG;1jj;a~STpjh2rPvw@QJO(GED*tX<}<T#(PVDc<Sh*z!`-O1_XI4
ze{F9$7k*2LO2;KuE&W#G%ur1zNAto+P2QafQp@gqdGTn)qi3(*FgG`^EtFyKgp)7d
z*!}5{M8wkt|17TuOHaBJ8u~hBVw1kCxID?0o;!pf9p}#|5-7gn!+`Bgu3V_eUiy4g
zaXj`3eN!;2GBYMkJxfhN!LKb-JFR54m`zv!yq0)0*D3y0%|fZv2)3`2qnG4xa;Xt4
z<gaO?n{#~n(1B`S`-afVNl86;_4+lx?cnF}{G}xaUz&>w{QUeE48l0IQ$IY|Hx>7s
zvuUv6x#N$44+cBaD=SWqF2}yS-7}LpA$*kT6YjD*(~y#_H;@-6Rv{u6cCcGqLPSKw
zPowQBb$4Fc@m%dqz8QaY;sx)w8<v(CqxI2Qk00;d?#6H5_LnG$i@Q8BGUBQ1lAK>Z
zD8kvf0(NULR)}<b9kHwEDPU(a>W&bykK5huo%2#Rj<9`fRkl7lp04MN_Om&MmvEDy
zBxSvL@nYGd=qUTG3oJZ;>qEIbGJ0YvV*hkYQ&W?n+K<<qCDS~ZrY8(u9YZf+uCAg{
zFq4sEm?$i>`XM4M+*taTLX{qLZ6b#V^}M{wJjA0@Q&Z!*57LXinVd8`c5IpUPM_Np
z2L{(aH@8Ub&sxWEj7!XJZ2X4Pu-E+1d<o;}#!Vsw$(Q@8Tn-p<f!C3ooE#ARNp^NN
z-`y`1At52AUvX!sg&p2JK1i2(MlRF@?DdtnXEC!W9FwkM$Fxd+2Cl63G&m`y-y($0
zb8xf<oRXRrPRFyJ3$b$Lv~!%j$kp(Jm`Oi9hA(dwU9FL9_Oy~628?BMl03D9mq*x4
zj!|7xPQ5r=O}2`TPG)knm*(c`T>E%q{Bn!3V#?dMH*hNI>d6edYgHRly1S{ctFQ;A
zlPxJ5o%LQxmmch0F7~@|jv0ob$K7!;`GLlMVgy?_wYWM*8Gs|;*7$LN7?GU(zTJH<
zngCd8`Mbma70P=3S|;)Rvc|*tD&21tIWqPIM~27BE#?d>Oqu%X0kWo&U;~&{XU&w>
zE8Y0_9Fi^oH>-I|DQ58U>vkD{UfT**y*GC1L9;r_R7ZE1Q-oY3owHJuM>5a8J`aoT
zc@Hru^n05KBx2G^to)lL`1;nvMir6>5^*0Mbv^dfHrgrsiff@1je#2<Hi$-+SP5gk
zYihb5^k(4&?!znrx7obBgTjB@aMso1`d`OJy(%rFETUd(+DexW-Gd+-6a)=6vwUI4
zLn&pI!YDdiz4b8!+pr2Y6oiZ_TI222C*y|~E2Bo2U3qiuD$i{INgUwjyZ<;rmL%fF
zfC0*8$RrWzV3E4S3uEN@DEVxt65In9y%U50%UFF9EP^19QFe)(c#Hs)|2rSN3?{>7
z;dhF!UAsm}LOg6&l<T#<@v@4erYY{qbNGeNW<XNgbtJ@XEYkT-<#az@m)H1PaQjq9
z`&4UfIPY==l`iuFH%_ro%53d<?&9v1vd1D3c@p4nFq6j41S~^9Gg=-|>AdO8F`i0#
zZ8f>DmTg#*>#=SpwmF?6yt}oythl?R_=;QqKDbFSVCdIyNs7^#iW1u@U?jK%{O%^c
z9ln%jJ5>3QUasj)Kcnimkjw77`E^GFo`qf8lbC{s&r!hPugNZXs{9?MVAU&(x<VXN
zjyDi0@X4=4oHLnIN=vnYL1-2`q|6piah7h*mYhF#uAwdCHox1F38o4C!>IPe_HveY
z>mDkthBVJ7f3nM{GNE#5`1ba90gTM<`9daLu)(recGS!VXlNIAJV})nD1W@;<Kuf%
zRHX5f(a0$(wintCsVFO-#&l&HK7X%c&9{YVG7Qr`o7GN3XYj&C=I+@{xf9L(C=2hO
z==_QC4&MRvdV1I~)nC8*bVdaQ9ra9y9y>cbwaYGwh=>R$iOkH*kUqM6p&+=R<m?Kc
z1yv|z*U^(<&rrnC7UV>nfGu8F<*0eq>9jP|>no&r<;s<%xWiz@K#10kS%m$Gu*Ei7
z$kMt8uEp?dR$}5AVYczb^`%Z@ZKBHE?fzZIaG|ZF^~Eu^6J%GdeSLjx(|gV)uX?;^
z;s1rL=-ajR^<nj6$|zOp20x*yt(_4U$AoEmdBK2^Y_IC=+cb2Gl{D7ppo=O8mf!p-
zbYbBclX`z@a=2pHun-#$=P?w(ie<kd9c^t%bRteBRep3hCMvJ#j(1Yg9t%ENoMF|~
z)wy@S9?7^}pits8(==1ip9uhEy0J8YOPKQ*6FJYx*%s;CmjVsUfXx;!eiL!*b!=bW
zAl0jqg}5XO;*x4Vh)YEO{G0&yYXQrqwfUhEi)eoH&?wIp4UN#mg#|mY?WN`}yf^-;
zKYd1Wl-spOj~+F?+gzDxE?w<QBc~CN#a)w=Lmj#2)b0LBM>@aa7w@~vJdCe=y!CMd
zS^2(W(eO{;ZJjqs(9cF@crYfvo{8b`7q&qLQbgfdd>>v>3E0Bj?}fTC()bU;YviQ>
zZ`Bvu(pX&>i|gj<8b0C(k5O${rn6sZ6r`1;6`I}NWTrqA3GkBR3V?gPrAe8|0_~bY
z29&3MNH;)}i20q!H~?jws!Rvq=!QXFks83M<HL1l^(<(BY!DMrJdFqVyO8YZZ-jwx
z>xSj0vd_mts!eDQBAyV<eZDDYUjKdWZske;%I`=63kg<|*3j7Kvtz{k-<mWgu4^o~
z^ZK=pYI<2GoFQ|&_qV1+%~}B3j44$xu3Jiy66Jkywt~pgenLhH<BCUK84(w*iCa&b
z>O^0BaGaYZK8CMpvckS)adbZ#6e%3>gxPsMv|&#tK4N^(iuNGmJD1(ijZST3Kn38o
zGU8&#EKkJgI*t+V{@L?L`QiU_kon(+WpwlibE3_Y+>)zio7aWKWUAS4O+8NPdl1|2
z9Vg4%+SCB@Sh=_qiS`{-xp^}%-?IC-=hjNMbr?!GwVgT*1=PqGO<Sx3qRs`Y>9TCk
zKMBlIq`aC>ge4LbKz7DuB$QNDL!!KQTxWWUlmUcVAO_12b6=6JqNJiqOG#mM+w|XE
zJ4C~_H-Pe|Iv`Iv<J(Jb_RNBXn9v51*;@|IK+}6`h#}9SlSkXO;@HMY0Y2l(^W&@%
z61r^anJ@eR)xhAN_W_f!NT<fme56wv(ZZ-*JVf8ACd388fzr#<L<8SHJ!x%hjD7I}
z!Zw&q%V^!}_|=P+T?y0E7LndN>!^9QHZ|GRMt4I*d*d9XJ<$MTiFxt2t%|n^4N+eN
z5m|jdGHiHwI5n@)3wrnI3ur7wM@NUolYK5j<Umd_xU=%F68g7ioj2xocdWMusqhW3
zWDc#W>VWm7RnfO^-aG|JTRJj2dUi4ZVZPjLJWsa|!BiV+s5y@bEA;{GP7s+bltMjV
zk5$1{U+TogdI?=eN5|BxtT~>tloX7stE=1hM^t=<)xlQYM(*zJ*CojwT?U;<mHR|+
z)zCza0YLyGxwntj4_nck9qsB}ul{zT7{!M_T}OOBo=%A990r_cRBBpUD}Y;N<yE*$
zHpEI**VoTEz3-n>*U^a*UmJKp?``DfRxC=dSWAw5F#H!b`g1kNv5{!RzrO7?18x{X
zi|kDN&W2T$=g#_=nT17g|D2-DBLsK#)$Q{-Zo}UiPyP6^Jy<odkA!hVNB}9@TBu1)
zPgen+4^)=VYs*F3=EI&>V($4}U0qA%M2Ad(cW$f=`RAE7pA88P9<SxCZ}Gj@XW~48
zO#jwugeDmtL`mLtzmx(>5}=UNnE*ZRH{c+qK!Q+JQwy~!o;b^)^ZphD&+Tvm^6bYH
z#8!LkHwK?`4X<wU!$(Wk2A@~g*5;NtECm8b1N<>F6^og!CDVQtea2Z+F?qvAOF@S<
zK1PLFptGoIU%884DGBr8H44+oH~&l+idd1*U#4N&UMTD2sW|#HLfr5%nIvv#yZb{j
z_MXCTIq2mN7EIj-qGEUX$n(zpohlm7?j({SvaX<cY5s=CjHwuuFOu*c?qf?2CP4f^
z@QQC0n4aQUT$K+^NE#r38#%3;DKA2J0BuOHHo2i~QJ?z1zTl;2GeoebK`b-r3_n@L
z;6OO^!r4v1qly5rxCEV`6T@E|x-}*IWzIME;U%uON_!DOLIMiEQBYR&G4~Sa+Z|DW
z-ym2y{zq3Xe?>?sHscp@hX#Cp4V&-2_#Qsobq*976?FC!W8>#{W(E=mu<?Mo)b@RP
zB{epFd<DU~o+W9(d5IMWfEfJyspDU8a0194qNGwN)unwp&+}|#)M<#POsz`N2$3b2
zYq?L_|G?W;TK6F1$6#=R7a)d~=s8Za!_3-3*{Os75LJvIr68X+xPSNiQX8FaMK7A2
zVW)GK7GX4n5M!zDFG^)VE>L8*teKoOKO&?9JXg%BLcPzNAc6(y7IEXsI%k)cr6opY
zgNe#v8bT1vbF@iQPoNqXuK02J>DA{9$qbALvk)O8_Nekd$dXTIABrSA#><NA>JGE1
zKZ~Z0QjB1dxp?2o(z5mbo&zY?%*)L+8U7OJw(yn3@#~o|SsZ(flB;V`l<Vk8)KcSR
z{M(cj#S+0Fy0wG?hDom_>IXq2RVp>~V{LF<npV(l?++P?jX<!=rLDz!^RaJ{uLN!5
zGRrp1W;%0ZaJc}*9J*y%pxdGNHoUmbr~i>SFF(Hvx+84rQQBEeJbY26?8r_79rcqc
zs(O~e&nUvtX)E`&>w0I@)?VLUulH^n{u&hD%~d?kr0v}6=r;YX3i!Q>np#qk{n#}e
zNNOQLLGg)lVUw99v%<6Df5=2JfJo7F2atpWn<q=s-!Hhy6f^Ov8;Y#&leYfhQAs}6
ze=v$b)MM=}=!L<7froQE2g>hty?4!_rlxM`=}GrF%5s(AZ&bM1^Jw>P@qh-2*~fR#
zpDRl7bD#l{o{>>f<%^T?RrK!H-B)K-Wn`YTrEA1r>~oO<VFYBqQ09^0&ns*-z>3A4
za-TgTbuH~1=eT&Wpx&PdQ9ADXY3TXbQQP4T<Q%46V)s3JO_PRkWFmz3+mq_}rlpDI
z5vN^Cv!0P>mWKKoYGIa<sBoaieWH|KKw!mm8wqGKp{3UqjedGsW?wmYC&kv*Rx@*R
zWdnnFxHyhCoEjM$s~KCwD1~*Fg@%T5=G>2LYHl8xce!JQVCfqKMax{o56k!+{HHK&
zLXw`E`pi$n<wp!S0#%jI42O^ip5MFmrIFyrNSLmgp<yB{nu@Aw;`~t6)cpgT4bz=D
zBX&jTCZQ5RZ?R)no_UxRe%pzhnoqVlS+StR0kPTp$EG*>#(@5c&I=8nKwK=INP3;?
zGJj`zu3s0oloP#uUDta%&kNkU49z9{LNyx-#YJ`ytp4tz{GBIq^q%--1WBOp!_#?@
zf<lgH|Cgfr7x6Tgh{i=gV$UPrY-w_n1T-w>laK@TyY1W_gc<S<*rRGiX&5vdrxc~=
z9bGjt0r-1%V7qEf0g>bxpyb9LRe}Z(%s=1njccJ5jVWnwNdYP>4~noGYPIdcA45@I
zT(W#xq#(pPU0vqov9kn>;V39*0)OS?_3pp>Cz;)Y2<j6{BBgCjUG{4t;gF_qhost)
zrjyZCEx_mLO8_zEAl-kRtGl6Cr=#^ui`>K1OO2_95Q$)f@#_3m@^Qrv%fD?NkRu)6
zM}lDd5R!q1lvEpe5YMl_f0yj)*+&L+_L(>q2_Q5fCLeeRT%A9*Jggx^@<{0d30ov$
z!vnnq4gQkSk7j2{XNi8i#)3rnDVHNS%{X;>{luflSw@6VR?|nv^<jtt@)B^2(e#Yl
z$YC{M0zFcAJt1T~MCR56F_slj4X5_|rKErP(f|eQ$8GTqE$_Z}GH`ugpQR$-vh#aX
zD{@Oy;Xa@X&!<Nv{Gs!l^RF^+7UF)n-xmiU#Vy68qwBJJ7Ku9IbuWNSn1+gB`$^A9
z)j=`yknwE-Zkagr@hBxXm`^ZSIjf5&hMkZx;N$=5&EOv$&{nPdL>E+xMX4T&1pRaE
zX!r*L-Yrwpz#jL_nF90W$<_<~7a@?h>@Chy-;D96z`+cLY9^|}Z2nRAoyjD{q-O2z
z{E8?fbu~Z|P|MIvY)w-)U;FXhZL#hmzx#>>sP(<h{hp1s6%`d5GuGZTr4oAOh)DGw
zh45c$jnnkbk*|Is3bYws4^)KINoTgZ1r#OE>zqFp+@(&13k}lM#XT}08VKdM?EnI^
z`NHs5T!Q^KAsPJc_T2L5YwOAvzu0t6yflJ&lN>_w>cKw9UkNKnMZVb}Z(^_t^7FbX
zB_B9bASy#bY%$PLkNDAvsAZLHr1p95dSaTot??NkL{D{@XZfBi0On?BY&-=%q#ccf
zLqm_lU;~J6`7nO_NEaB6HxP>tSp*Nr9Bg2WfR_PP?~VSa$6sfh(&FQ#o>OtP<(f9f
z8KA71VQXMtbxn;j(8c5Iw_?&Vi?4MTSgX6axrIe{0%KoUSsCBHaV|Ij=<f-Z>>~up
z$!_}2^3$gMoImr2oV%O**$!YI5Dh%%Dtp6k-exk>l}9b^QRp<?5u2UOvxktN?iIfr
z&S5H};A$1s@#B-g5!HYR>$pvvkq_rdtf^0b^X3My?~i^2l6T%6xfGG-c^uM@gO%@+
zu?!wRF2S@Fm6H`(pB_HVXFqzqE}U29*s)_`UjBbFYAc3l3GcG|AM}>mIyySkM~L1M
zupR!~IUxj50HYPH2+<mZM}6)ek0Z!ocC;4YN_VM)T}dzLlTTt^^<&ZAnZVZ9w|l+I
zMa0BPyOlp75wZ4X?vD=Kvy#XgRZ3tu$#!^2N$2LUS^tfo;$7MpwgnfRn{jMJFUBC8
z!{LsgT$rnL2`9d@W`GJ8HDO%sz^Tt+z@s!19TJV<xSc;f<S)^dB>!3k(ht1#qP)U;
zu^Q-({o*HX9#?;|6Fs6Tfq&o}=O{=_x^hk3h682z;9Ppb2`m2om}aT%w)F%odH`4n
zC>zTi2L2$67l26wG6zWRw_v``P%b!?e`r7>@Q2KS6CK!9>wWvmr3a`;WGQH<_vaju
zjd*v21V=L0Ph772k&7Y#5#v8HEBZ+Gv_8V}6dHT)rN9z3$e#EqAxJI=2VVV%V0BId
zcIogP*^3niPz`u*!c6v4L|}Av6gV>5B$XM&)}-(dTH0Jj(TmFWAwi5HU@>#S{U+Ho
zs`{JcFU1Hn%aL-7-85Wi6VL!49NJT`0Dz~Q`oAyGM_9RfPR(Qnc8Lcm)CVp+OW-T$
zRV5I!n<hhp<7LPivO!3V#>PcsQE6xb=(~-eaAh_-hi0xU$d>4n5Otjt=RVh}%2Wb`
zH5qb3(y_T4!V~@yFFZWsxU=bGmHf!Da$%gUsj6wYphlsZre?lHxYy2N^i(^3$I+qo
zx7wO<>)qw<e9NHvvF3;Sk3!{xnZXEx4ZexLwDHMO$;5hk<%aTIky8|y>URV-5D6CV
zY)tXHF5Ha-xGG*BMH55PrEo<xRYlSHhxBgar@&0FfH0<6>XuiwG0B#pUD7r>Nq}Hr
z-XPK5bzB?>v_$a+%RJP92s%yQD&3e&bKBisJ%h2vZ|4hG_obU>m8#)d8X96oM~&no
z1TSoeO-xKsU$lxaGczmR4*xB5UPQ35PVEkn>(BKuv0{O?k~rJxD~$GI-yjBWd8_|v
z*r@~+8!DbtnS(*#5}-4Tl7fOl?dr(zu*vFdZ|_bm5XO+OuvN?N2)3nRMFYaK{lj3S
zRJtBF&D+u&fmf+QDg->hRP^q8be`Mt<V#!5Ft*V$Lk;bG$5(%cBgV@_2(D*BsEWZJ
z=0=Qe=z~MzZ(J8g(aZ@h;qd9J=r>c}ylF_+$N{#_e8q@x+sk`tQ&Us3xR%uEnxY~K
zr2SNf5LqwRD>xR4qJjACdV*pm|FL6dig^YKe?t>12gk|}NZ{s@U;i@+<<B7Mas#;O
z`SXMR#}FG@Q>zr0i9ivVXdz)c{F?0s0TZi`)84mGOn?G9<c#<{)@(|b+iq)?c@)hS
z4jse<D&s*D*UY}_gXW%MrJk6fsVF{^01)1-?3dwK+(3gMtzokPYaNQg{n8(Gp{gX0
zplSe3Fu6_zw?pB~o&(2GK5AxadXtf&0sO|&m(%_x<yZn7Q}iku7gsw-0vVtKm@kbt
zx=p4etK7QPk>>eJ7WrAP5mhEii#+90%Y4ceRUiCuv)}=d9up*#7|*m?kLy>OvGS^M
z6GCvY1Ig(anshA!NdN-weQfH8AW$PDNpFM{kpToLr-Ww%B!rAWnL^kQT7Vx!*&$P_
zG11hP1=Qu|@FUS*+YNuIJ{DTVkkh$9%*3YIu#bZKzCqZ1BE%t!$HRwS<VS+tp|T7M
z&)DOha=!aGTkiiLIo7RBi+u=G3wsF^go#;x$86@Ao0l9)*c@bmt~NuK2a-K=>-!KJ
zG~C9X`o&Wj(#UgBx_Y{nG#1+oB(<CZCC8Ma4MRhJCn}&q0Wl(#o4Z20qhLgfZMlNp
z-bJ<6KW?;ss|c1cBdbQ^zp_u|d(jnn2wddRnLsvgcN3zFM`!lfB`;GRCJ@{M$$T=U
zzb2qe2#8KR1eU7z5=uqRQm*|i|8`PnraO$+n@*oCc9Y1)0_`^77sXNdQU()F@i6eb
zet;V4Tz~_=v?aFq$f^ewG80;^!{a*-{$5%+sV4wC5u^Bafh6EPAU#(6L-lFN1tx?L
z+y$FI@)cM-GJZ5&l#rS0KW#{cHuSmL0B;*sRi8%ue9@QeeY9MO%ja#;nB;%1M9w!x
z@t&au4k+$j`!fg<Qy|=5AktqYFO7)q$;imSK`EEkYc{C<U`fr(Q`O08pXIUmo_*a9
zpL~w?pgCF=R$CifGxCC;Ln<}^idkAaI)1Ta+p76Q0Y9!hTaT1FOqH=lsOIh4$4H2S
zLybn0zrQ39-D7HMDhzq98P0e`7tyHTT_TC&znc3F$yq80i7OlL2#23^hfn{m7JK2|
z2#L38PQtGhGfq=bb)bUx`nL5DsS4{7ENiKR&m}WNV+u*oY%6yJT0Zp8O9LM=r$9zM
zOv}!PhnF`bGBSh4s_@cW>1tH3;c_@&VUZRmXw9A4*Lontl;Jh1Z5a6QfZwEnQQM*M
zN>`a@Nv~l=#eeFjI%b;`s;9E>nZR*?$w6lsx_I$X+nVfLlSU@^g`8IKhPsYxVxQ|6
z-Ro2_+bZEQsV4_bXM2jMFWh;E%9zlo*QwjGtHe3W_gM7Hq3zwxBq&;tgYqZvFVci;
zqWq;oWkA2x6B82`+|Vs(fy`NwqWJpf$7Z(KKXb(D>QgKd>puBby`Y_(rxW+Mg=*eV
z=Va<^YFl90Eg-g7%eyh_j5l{?waxL~_0slQADQgO<98M%c9oZxmp3Z7yke~(iQ^P@
zoa$dV(!Acp$l(7%HOJFTiKuBmM-N@k<&eqA$y~h;gaFkOXek#;*r8gh>&C=ap}t+b
z0u*_*(^$Wcm1GQvsU941sakE6VK9Y+7qx)JO94>I3;MloA2`l_<LcF`_t`2~-(jtC
zb8~Ou(xCvMM9wD-vIXYj4Y6t<`14!!2u_u4&gPUP6uyL1CqMYwlA3YeAQr`ZKzzTK
zmdZ)j-x<}u)K|VTfBLItftB`>mmqCElr=1a;ww`?Cuma+YupAjV*1>CFs-LYZ%Rf+
z9<xS?^PIvB)%oV;dC!fB<Tg-L41vejKxB~PwO*s!b)z?BYIe=4bXiSiYbM<9q@)An
z3a{bN+(0ICnb$&4v<U<~#o+g6IL~AXSaieyGrc9T_Tf-4oJlBfnndfuW;ofbD*fov
z)O9^o=kU8_%o7mawL!|jaVD?5OG{&m|DR@64GauDSx%5aNvDuer7&13)S<ck_^^*3
z99~I{PnwNjdYFzI26%iKT1N+=5$cSpM9KYzr4ebWP{WCx&AIlDcLu7rZkad>*)D!O
zz-0nSKJeUcOM(kG`**i>Gqj47;N-SK8av&4?TL2-ngAS&a{o5lG<XM&^D6<%SC7eQ
zl6JN?%|Qb^&&JjazHpk8V-~7u&R`(le4*Rk&MwYh=qr>F@mcqY%14Vs4O!K!-Qb;x
zro_qitmxU&RUO#T5{TFG^71C;s~FU6ZQtp*jvVWC8S;I_WB3dtqZ!UaEZ97)h6;(D
zA&E)voiXoR*F__E?KQ+GXqf6Y5~5DKE))W@M%P#_ls%9cEgYMBzv!oysg=@gRZ=%P
zsnGkc;<1|9g^h=3uE`oz$Wmq@OMzCIef<7*XGC|W0v$7~4=Qv5SsE+c)y2h8>1caz
zFTdh7_G6xa8X+a9-$O%b$kumi&?_Lk*r&GjVyh-lxaJ0%>F~3pR-wnDzf7BhgJYv_
zwJaG54pMaSUa6UxZCPH+Y*2iq2zef-FqdmvUU*Vc(mVN{V<P>wwW_X%#MffrR3xV;
zC!2kKdia%)eG+W>(3eiF=z126w$X2bm6Q!THW7N;>gKOx2QBaBY8Za&3Ve{7=dSEh
zo)OTq4KT`7Ah%Vs3ksd##!)FS455wXO3GT~veI3r?@{ivjm3^ru$gB;_v_YH(%SCr
z-;Q*e?KzoaxiZ~}TIuMwNVbA*OJ&1(Td25mHtk-70|nftKIz%uR9aS<lBVV~UcJ}K
zxjO%zQ0Uf{2b2IpqTCb?3N8VP5mSqcH34+;ii+39$-E(`y{F?o!w-dl9kaMWBbb`D
zxPeC<f4d3%iDqi#RV(VT1Vj!XG7F+ZC6<(ZrbYYCX+{&(ch!uHj2u=zOf8#%04t#G
zJPF8O;t@5U+pN$G;7&I$R3&6T`sU3WSvVVw90fgbU0s?eK)Q{F8^ej^gc=Z3EF?e4
zBmL>gq4wL>rHLaoVN-r0vu{gsgPI_Dbx2~1+YKKZdr8D;`Ud2C9+RDngJ7ORBU>6Z
z5;!h-kfQ%Xn|wFfC(<^L0=>s#9US3iw3Y*uhSM8vK_MZD1Vno~RGqTu=63rV@8x^%
z?kuc(6c5}#a723&Bh)u91}U*(pskJ-$J9->*5)C3)l%t8gQll8pH=$gte?NjydTrs
z=e610-=(b?ZL36cq9!{X3fD9tC{cq{8oxyc_Y`dHJAlRgk1n@C0h%#P?sN5*FK@qz
zt!hm{;aoQ8-ZPvt3GY|B%zJlAL6d+!WZ7OmIzXi<9$gPqy&$u2kQCMASB`rU0<=RR
zmsnXJ+TJOwkF9ER*Ev_koT&Nr&}N;rmw_jYCZC6gCmo7u8#M7=rJj3+5(=R-WkcKu
w3V0YbYz{*O&;RD4p1)*f{_TZBqq{_``+NF|9zJLRaTvi|QIO8OtatxE0MK}v%m4rY

literal 0
HcmV?d00001

diff --git a/contrib/plotting-visualization/images/simple_scatter.png b/contrib/plotting-visualization/images/simple_scatter.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfa5b408811a67c88c7a42c396be6a327a3a971e
GIT binary patch
literal 11079
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

literal 0
HcmV?d00001


From 204e4340af8160b69366b3b5f6b1f213d1777bc5 Mon Sep 17 00:00:00 2001
From: Dishika Vaishkiyar <152963337+Dishika18@users.noreply.github.com>
Date: Tue, 4 Jun 2024 00:22:12 +0530
Subject: [PATCH 31/76] Create matplotlib-scatter-plot.md

---
 .../matplotlib-scatter-plot.md                | 155 ++++++++++++++++++
 1 file changed, 155 insertions(+)
 create mode 100644 contrib/plotting-visualization/matplotlib-scatter-plot.md

diff --git a/contrib/plotting-visualization/matplotlib-scatter-plot.md b/contrib/plotting-visualization/matplotlib-scatter-plot.md
new file mode 100644
index 0000000..a9fa500
--- /dev/null
+++ b/contrib/plotting-visualization/matplotlib-scatter-plot.md
@@ -0,0 +1,155 @@
+# Scatter() plot in matplotlib
+* A scatter plot is a type of data visualization that uses dots to show values for two variables, with one variable on the x-axis and the other on the y-axis. It's useful for identifying relationships, trends, and correlations, as well as spotting clusters and outliers.
+* The dots on the plot shows how the variables are related. A scatter plot is made with the matplotlib library's `scatter() method`.
+## Syntax
+**Here's how to write code for the scatter() method:**
+```
+matplotlib.pyplot.scatter (x_axis_value, y_axis_value, s = None, c = None, vmin = None, vmax = None, marker = None, cmap = None, alpha = None, linewidths = None, edgecolors = None)
+
+```
+## Prerequisites
+Scatter plots can be created in Python with Matplotlib's pyplot library. To build a Scatter plot, first import matplotlib. It is a standard convention to import Matplotlib's pyplot library as plt.
+```
+import matplotlib.pyplot as plt
+
+```
+## Creating a simple Scatter Plot
+With Pyplot, you can use the `scatter()` function to draw a scatter plot.
+
+The `scatter()` function plots one dot for each observation. It needs two arrays of the same length, one for the values of the x-axis, and one for values on the y-axis:
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+
+plt.scatter(x, y)
+plt.show()
+```
+
+When executed, this will show the following Scatter plot:
+
+
+
+## Compare Plots
+
+In a scatter plot, comparing plots involves examining multiple sets of points to identify differences or similarities in patterns, trends, or correlations between the data sets.
+
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+#day one, the age and speed of 13 cars:
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+plt.scatter(x, y)
+
+#day two, the age and speed of 15 cars:
+x = np.array([2,2,8,1,15,8,12,9,7,3,11,4,7,14,12])
+y = np.array([100,105,84,105,90,99,90,95,94,100,79,112,91,80,85])
+plt.scatter(x, y)
+
+plt.show()
+```
+
+When executed, this will show the following Compare Scatter plot:
+
+## Colors in Scatter plot
+You can set your own color for each scatter plot with the `color` or the `c` argument:
+
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+plt.scatter(x, y, color = 'hotpink')
+
+x = np.array([2,2,8,1,15,8,12,9,7,3,11,4,7,14,12])
+y = np.array([100,105,84,105,90,99,90,95,94,100,79,112,91,80,85])
+plt.scatter(x, y, color = '#88c999')
+
+plt.show()
+```
+
+When executed, this will show the following Colors Scatter plot:
+
+## Color Each Dot
+You can even set a specific color for each dot by using an array of colors as value for the `c` argument:
+
+``**Note:** You cannot use the `color` argument for this, only the `c` argument.``
+
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+colors = np.array(["red","green","blue","yellow","pink","black","orange","purple","beige","brown","gray","cyan","magenta"])
+
+plt.scatter(x, y, c=colors)
+
+plt.show()
+```
+
+When executed, this will show the following Color Each Dot:
+
+## ColorMap
+The Matplotlib module has a number of available colormaps.
+
+A colormap is like a list of colors, where each color has a value that ranges from 0 to 100.
+
+Here is an example of a colormap:
+
+
+
+
+This colormap is called 'viridis' and as you can see it ranges from 0, which is a purple color, up to 100, which is a yellow color.
+
+## How to Use the ColorMap
+You can specify the colormap with the keyword argument `cmap` with the value of the colormap, in this case `'viridis'` which is one of the built-in colormaps available in Matplotlib.
+
+In addition you have to create an array with values (from 0 to 100), one value for each point in the scatter plot:
+
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+colors = np.array([0, 10, 20, 30, 40, 45, 50, 55, 60, 70, 80, 90, 100])
+
+plt.scatter(x, y, c=colors, cmap='viridis')
+
+plt.show()
+```
+
+When executed, this will show the following Scatter ColorMap:
+
+
+
+You can include the colormap in the drawing by including the `plt.colorbar()` statement:
+
+```
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
+y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
+colors = np.array([0, 10, 20, 30, 40, 45, 50, 55, 60, 70, 80, 90, 100])
+
+plt.scatter(x, y, c=colors, cmap='viridis')
+
+plt.colorbar()
+
+plt.show()
+```
+
+When executed, this will show the following Scatter ColorMap using `plt.colorbar()`:
+
+
+
+
+
+

From edd8aec3a2b1f9855e7456d0065520d9a43243e2 Mon Sep 17 00:00:00 2001
From: rohit <codyyrohit@gmail.com>
Date: Tue, 4 Jun 2024 00:28:41 +0530
Subject: [PATCH 32/76] Added K-Nearest Neighbors (KNN).md file

---
 .../K-nearest neighbor (KNN).md               | 122 ++++++++++++++++++
 contrib/machine-learning/index.md             |   1 +
 2 files changed, 123 insertions(+)
 create mode 100644 contrib/machine-learning/K-nearest neighbor (KNN).md

diff --git a/contrib/machine-learning/K-nearest neighbor (KNN).md b/contrib/machine-learning/K-nearest neighbor (KNN).md
new file mode 100644
index 0000000..748f808
--- /dev/null
+++ b/contrib/machine-learning/K-nearest neighbor (KNN).md	
@@ -0,0 +1,122 @@
+# K-Nearest Neighbors (KNN) Machine Learning Algorithm in Python
+
+## Introduction
+K-Nearest Neighbors (KNN) is a simple, yet powerful, supervised machine learning algorithm used for both classification and regression tasks. It assumes that similar things exist in close proximity. In other words, similar data points are near to each other.
+
+## How KNN Works
+KNN works by finding the distances between a query and all the examples in the data, selecting the specified number of examples (K) closest to the query, then voting for the most frequent label (in classification) or averaging the labels (in regression).
+
+### Steps:
+1. **Choose the number K of neighbors**
+2. **Calculate the distance** between the query-instance and all the training samples
+3. **Sort the distances** and determine the nearest neighbors based on the K-th minimum distance
+4. **Gather the labels** of the nearest neighbors
+5. **Vote for the most frequent label** (in case of classification) or **average the labels** (in case of regression)
+
+## When to Use KNN
+### Advantages:
+- **Simple and easy to understand:** KNN is intuitive and easy to implement.
+- **No training phase:** KNN is a lazy learner, meaning there is no explicit training phase.
+- **Effective with a small dataset:** KNN performs well with a small number of input variables.
+
+### Disadvantages:
+- **Computationally expensive:** The algorithm becomes significantly slower as the number of examples and/or predictors/independent variables increase.
+- **Sensitive to irrelevant features:** All features contribute to the distance equally.
+- **Memory-intensive:** Storing all the training data can be costly.
+
+### Use Cases:
+- **Recommender Systems:** Suggest items based on similarity to user preferences.
+- **Image Recognition:** Classify images by comparing new images to the training set.
+- **Finance:** Predict credit risk or fraud detection based on historical data.
+
+## KNN in Python
+
+### Required Libraries
+To implement KNN, we need the following Python libraries:
+- `numpy`
+- `pandas`
+- `scikit-learn`
+- `matplotlib` (for visualization)
+
+### Installation
+```bash
+pip install numpy pandas scikit-learn matplotlib
+```
+
+### Example Code
+Let's implement a simple KNN classifier using the Iris dataset.
+
+#### Step 1: Import Libraries
+```python
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+```
+
+#### Step 2: Load Dataset
+```python
+from sklearn.datasets import load_iris
+iris = load_iris()
+X = iris.data
+y = iris.target
+```
+
+#### Step 3: Split Dataset
+```python
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+```
+
+#### Step 4: Train KNN Model
+```python
+knn = KNeighborsClassifier(n_neighbors=3)
+knn.fit(X_train, y_train)
+```
+
+#### Step 5: Make Predictions
+```python
+y_pred = knn.predict(X_test)
+```
+
+#### Step 6: Evaluate the Model
+```python
+accuracy = accuracy_score(y_test, y_pred)
+print(f'Accuracy: {accuracy}')
+```
+
+### Visualization (Optional)
+```python
+# Plotting the decision boundary for visualization (for 2D data)
+h = .02  # step size in the mesh
+# Create color maps
+cmap_light = plt.cm.RdYlBu
+cmap_bold = plt.cm.RdYlBu
+
+# For simplicity, we take only the first two features of the dataset
+X_plot = X[:, :2]
+x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1
+y_min, y_max = X_plot[:, 1].min() - 1, y_plot[:, 1].max() + 1
+xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                     np.arange(y_min, y_max, h))
+
+Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
+Z = Z.reshape(xx.shape)
+plt.figure()
+plt.pcolormesh(xx, yy, Z, cmap=cmap_light)
+
+# Plot also the training points
+plt.scatter(X_plot[:, 0], X_plot[:, 1], c=y, edgecolor='k', cmap=cmap_bold)
+plt.xlim(xx.min(), xx.max())
+plt.ylim(yy.min(), yy.max())
+plt.title("3-Class classification (k = 3)")
+plt.show()
+```
+
+## Generalization and Considerations
+- **Choosing K:** The choice of K is critical. Smaller values of K can lead to noisy models, while larger values make the algorithm computationally expensive and might oversimplify the model.
+- **Feature Scaling:** Since KNN relies on distance calculations, features should be scaled (standardized or normalized) to ensure that all features contribute equally to the distance computation.
+- **Distance Metrics:** The choice of distance metric (Euclidean, Manhattan, etc.) can affect the performance of the algorithm.
+
+In conclusion, KNN is a versatile and easy-to-implement algorithm suitable for various classification and regression tasks, particularly when working with small datasets and well-defined features. However, careful consideration should be given to the choice of K, feature scaling, and distance metrics to optimize its performance.
\ No newline at end of file
diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index b6945cd..e5f5371 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -16,3 +16,4 @@
 - [Types_of_Cost_Functions](cost-functions.md)
 - [Clustering](clustering.md)
 - [Grid Search](grid-search.md)
+- [K-nearest neighbor (KNN)](K-nearest neighbor (KNN).md)
\ No newline at end of file

From c812fa29ac87b29857bb3c95ffbaeb766c5b5f8e Mon Sep 17 00:00:00 2001
From: Dishika Vaishkiyar <152963337+Dishika18@users.noreply.github.com>
Date: Tue, 4 Jun 2024 00:35:40 +0530
Subject: [PATCH 33/76] Update matplotlib-scatter-plot.md

---
 .../matplotlib-scatter-plot.md                | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/contrib/plotting-visualization/matplotlib-scatter-plot.md b/contrib/plotting-visualization/matplotlib-scatter-plot.md
index a9fa500..535a3a3 100644
--- a/contrib/plotting-visualization/matplotlib-scatter-plot.md
+++ b/contrib/plotting-visualization/matplotlib-scatter-plot.md
@@ -2,7 +2,7 @@
 * A scatter plot is a type of data visualization that uses dots to show values for two variables, with one variable on the x-axis and the other on the y-axis. It's useful for identifying relationships, trends, and correlations, as well as spotting clusters and outliers.
 * The dots on the plot shows how the variables are related. A scatter plot is made with the matplotlib library's `scatter() method`.
 ## Syntax
-**Here's how to write code for the scatter() method:**
+**Here's how to write code for the `scatter() method`:**
 ```
 matplotlib.pyplot.scatter (x_axis_value, y_axis_value, s = None, c = None, vmin = None, vmax = None, marker = None, cmap = None, alpha = None, linewidths = None, edgecolors = None)
 
@@ -30,7 +30,7 @@ plt.show()
 
 When executed, this will show the following Scatter plot:
 
-
+![Basic line Chart](images/simple_scatter.png)
 
 ## Compare Plots
 
@@ -55,6 +55,8 @@ plt.show()
 
 When executed, this will show the following Compare Scatter plot:
 
+![Compare Plots](images/scatter_compare.png)
+
 ## Colors in Scatter plot
 You can set your own color for each scatter plot with the `color` or the `c` argument:
 
@@ -75,10 +77,12 @@ plt.show()
 
 When executed, this will show the following Colors Scatter plot:
 
+![Colors in Scatter plot](images/scatter_color.png)
+
 ## Color Each Dot
 You can even set a specific color for each dot by using an array of colors as value for the `c` argument:
 
-``**Note:** You cannot use the `color` argument for this, only the `c` argument.``
+``Note: You cannot use the `color` argument for this, only the `c` argument.``
 
 ```
 import matplotlib.pyplot as plt
@@ -95,6 +99,8 @@ plt.show()
 
 When executed, this will show the following Color Each Dot:
 
+![Color Each Dot](images/scatter_coloreachdot.png)
+
 ## ColorMap
 The Matplotlib module has a number of available colormaps.
 
@@ -102,8 +108,7 @@ A colormap is like a list of colors, where each color has a value that ranges fr
 
 Here is an example of a colormap:
 
-
-
+![ColorMap](images/img_colorbar.png)
 
 This colormap is called 'viridis' and as you can see it ranges from 0, which is a purple color, up to 100, which is a yellow color.
 
@@ -127,7 +132,7 @@ plt.show()
 
 When executed, this will show the following Scatter ColorMap:
 
-
+![Scatter ColorMap](images/scatter_colormap1.png)
 
 You can include the colormap in the drawing by including the `plt.colorbar()` statement:
 
@@ -148,7 +153,7 @@ plt.show()
 
 When executed, this will show the following Scatter ColorMap using `plt.colorbar()`:
 
-
+![Scatter ColorMap1](images/scatter_colormap2.png)
 
 
 

From 93eae0c0c908f7563c096c4563e9ac37a96a9b5e Mon Sep 17 00:00:00 2001
From: Dishika Vaishkiyar <152963337+Dishika18@users.noreply.github.com>
Date: Tue, 4 Jun 2024 00:38:23 +0530
Subject: [PATCH 34/76] Update index.md

---
 contrib/plotting-visualization/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/plotting-visualization/index.md b/contrib/plotting-visualization/index.md
index 3192f03..7e43d9b 100644
--- a/contrib/plotting-visualization/index.md
+++ b/contrib/plotting-visualization/index.md
@@ -5,5 +5,6 @@
 - [Bar Plots in Matplotlib](matplotlib-bar-plots.md)
 - [Pie Charts in Matplotlib](matplotlib-pie-charts.md)
 - [Line Charts in Matplotlib](matplotlib-line-plots.md)
+- [Scatter Plots in Matplotlib](matplotlib-scatter-plot.md)
 - [Introduction to Seaborn and Installation](seaborn-intro.md)
 - [Getting started with Seaborn](seaborn-basics.md)

From ff13658e4ab3cf70a592b27a8a9562847f12f624 Mon Sep 17 00:00:00 2001
From: SAM <8dmasters@gmail.com>
Date: Tue, 4 Jun 2024 01:07:24 +0530
Subject: [PATCH 35/76] Create match_case_statement.md

---
 contrib/advanced-python/match_case_statement.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 contrib/advanced-python/match_case_statement.md

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
new file mode 100644
index 0000000..e69de29

From 3ac978f6a97fa53d1a111d3fb0132984a13ce6de Mon Sep 17 00:00:00 2001
From: SAM <8dmasters@gmail.com>
Date: Tue, 4 Jun 2024 01:07:36 +0530
Subject: [PATCH 36/76] Update index.md

Added match_case_statement index
---
 contrib/advanced-python/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index b31544e..c262aaa 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,3 +10,4 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
+- [Match Case Statement](match_case_statement.md)
\ No newline at end of file

From 5678bc9cf3bfb93c1d938d56b06c11a36e3f94b1 Mon Sep 17 00:00:00 2001
From: Kosuri Indu <kosurilindu@gmail.com>
Date: Tue, 4 Jun 2024 08:19:32 +0530
Subject: [PATCH 37/76] Added Hashing through linear probing

---
 .../ds-algorithms/hashing-linear-probing.md   | 139 ++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 contrib/ds-algorithms/hashing-linear-probing.md

diff --git a/contrib/ds-algorithms/hashing-linear-probing.md b/contrib/ds-algorithms/hashing-linear-probing.md
new file mode 100644
index 0000000..0d27db4
--- /dev/null
+++ b/contrib/ds-algorithms/hashing-linear-probing.md
@@ -0,0 +1,139 @@
+# Hashing with Linear Probing
+
+In Data Structures and Algorithms, hashing is used to map data of arbitrary size to fixed-size values. A common approach to handle collisions in hashing is **linear probing**. In linear probing, if a collision occurs (i.e., the hash value points to an already occupied slot), we linearly probe through the table to find the next available slot. This method ensures that every element can be inserted or found in the hash table.
+
+## Points to be Remembered
+
+- **Hash Function**: A function that converts an input (or 'key') into an index in a hash table.
+- **Collision**: When two keys hash to the same index.
+- **Linear Probing**: A method to resolve collisions by checking the next slot (i.e., index + 1) until an empty slot is found.
+
+## Real Life Examples of Hashing with Linear Probing
+
+- **Student Record System**: Each student record is stored in a table where the student's ID number is hashed to an index. If two students have the same hash index, linear probing finds the next available slot.
+- **Library System**: Books are indexed by their ISBN numbers. If two books hash to the same slot, linear probing helps find another spot for the book in the catalog.
+
+## Applications of Hashing
+
+Hashing is widely used in Computer Science:
+
+- **Database Indexing**
+- **Caches** (like CPU caches, web caches)
+- **Associative Arrays** (or dictionaries in Python)
+- **Sets** (unordered collections of unique elements)
+
+Understanding these applications is essential for Software Development.
+
+## Operations in Hash Table with Linear Probing
+
+Key operations include:
+
+- **INSERT**: Insert a new element into the hash table.
+- **SEARCH**: Find the position of an element in the hash table.
+- **DELETE**: Remove an element from the hash table.
+
+## Implementing Hash Table with Linear Probing in Python
+
+```python
+class HashTable:
+    def __init__(self, size):
+        self.size = size
+        self.table = [None] * size
+    
+    def hash_function(self, key):
+        return key % self.size
+    
+    def insert(self, key, value):
+        hash_index = self.hash_function(key)
+        
+        if self.table[hash_index] is None:
+            self.table[hash_index] = (key, value)
+        else:
+            while self.table[hash_index] is not None:
+                hash_index = (hash_index + 1) % self.size
+            self.table[hash_index] = (key, value)
+    
+    def search(self, key):
+        hash_index = self.hash_function(key)
+        
+        while self.table[hash_index] is not None:
+            if self.table[hash_index][0] == key:
+                return self.table[hash_index][1]
+            hash_index = (hash_index + 1) % self.size
+        
+        return None
+    
+    def delete(self, key):
+        hash_index = self.hash_function(key)
+        
+        while self.table[hash_index] is not None:
+            if self.table[hash_index][0] == key:
+                self.table[hash_index] = None
+                return True
+            hash_index = (hash_index + 1) % self.size
+        
+        return False
+    
+    def display(self):
+        for index, item in enumerate(self.table):
+            print(f"Index {index}: {item}")
+
+# Example usage
+hash_table = HashTable(10)
+
+hash_table.insert(1, 'A')
+hash_table.insert(11, 'B')
+hash_table.insert(21, 'C')
+
+print("Hash Table after Insert operations:")
+hash_table.display()
+
+print("Search operation for key 11:", hash_table.search(11))
+
+hash_table.delete(11)
+
+print("Hash Table after Delete operation:")
+hash_table.display()
+```
+
+## Output
+
+```markdown
+Hash Table after Insert operations:
+Index 0: None
+Index 1: (1, 'A')
+Index 2: None
+Index 3: None
+Index 4: None
+Index 5: None
+Index 6: None
+Index 7: None
+Index 8: None
+Index 9: None
+Index 10: None
+Index 11: (11, 'B')
+Index 12: (21, 'C')
+
+Search operation for key 11: B
+
+Hash Table after Delete operation:
+Index 0: None
+Index 1: (1, 'A')
+Index 2: None
+Index 3: None
+Index 4: None
+Index 5: None
+Index 6: None
+Index 7: None
+Index 8: None
+Index 9: None
+Index 10: None
+Index 11: None
+Index 12: (21, 'C')
+```
+
+## Complexity Analysis
+
+- **Insertion**: Average case O(1), Worst case O(n) when many collisions occur.
+- **Search**: Average case O(1), Worst case O(n) when many collisions occur.
+- **Deletion**: Average case O(1), Worst case O(n) when many collisions occur.
\ No newline at end of file

From 96752204ead3ad9412e2da4fdd01abbbca860349 Mon Sep 17 00:00:00 2001
From: Kosuri Indu <kosurilindu@gmail.com>
Date: Tue, 4 Jun 2024 08:28:18 +0530
Subject: [PATCH 38/76] Added Hashing through Chaining

---
 contrib/ds-algorithms/hashing-chaining.md | 153 ++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 contrib/ds-algorithms/hashing-chaining.md

diff --git a/contrib/ds-algorithms/hashing-chaining.md b/contrib/ds-algorithms/hashing-chaining.md
new file mode 100644
index 0000000..34086b5
--- /dev/null
+++ b/contrib/ds-algorithms/hashing-chaining.md
@@ -0,0 +1,153 @@
+# Hashing with Chaining
+
+In Data Structures and Algorithms, hashing is used to map data of arbitrary size to fixed-size values. A common approach to handle collisions in hashing is **chaining**. In chaining, each slot of the hash table contains a linked list, and all elements that hash to the same slot are stored in that list.
+
+## Points to be Remembered
+
+- **Hash Function**: A function that converts an input (or 'key') into an index in a hash table.
+- **Collision**: When two keys hash to the same index.
+- **Chaining**: A method to resolve collisions by maintaining a linked list for each hash table slot.
+
+## Real Life Examples of Hashing with Chaining
+
+- **Phone Directory**: Contacts are stored in a hash table where the contact's name is hashed to an index. If multiple names hash to the same index, they are stored in a linked list at that index.
+- **Library Catalog**: Books are indexed by their titles. If multiple books have titles that hash to the same index, they are stored in a linked list at that index.
+
+## Applications of Hashing
+
+Hashing is widely used in Computer Science:
+
+- **Database Indexing**
+- **Caches** (like CPU caches, web caches)
+- **Associative Arrays** (or dictionaries in Python)
+- **Sets** (unordered collections of unique elements)
+
+Understanding these applications is essential for Software Development.
+
+## Operations in Hash Table with Chaining
+
+Key operations include:
+
+- **INSERT**: Insert a new element into the hash table.
+- **SEARCH**: Find the position of an element in the hash table.
+- **DELETE**: Remove an element from the hash table.
+
+## Implementing Hash Table with Chaining in Python
+
+```python
+class Node:
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+        self.next = None
+
+class HashTable:
+    def __init__(self, size):
+        self.size = size
+        self.table = [None] * size
+    
+    def hash_function(self, key):
+        return key % self.size
+    
+    def insert(self, key, value):
+        hash_index = self.hash_function(key)
+        new_node = Node(key, value)
+        
+        if self.table[hash_index] is None:
+            self.table[hash_index] = new_node
+        else:
+            current = self.table[hash_index]
+            while current.next is not None:
+                current = current.next
+            current.next = new_node
+    
+    def search(self, key):
+        hash_index = self.hash_function(key)
+        current = self.table[hash_index]
+        
+        while current is not None:
+            if current.key == key:
+                return current.value
+            current = current.next
+        
+        return None
+    
+    def delete(self, key):
+        hash_index = self.hash_function(key)
+        current = self.table[hash_index]
+        prev = None
+        
+        while current is not None:
+            if current.key == key:
+                if prev is None:
+                    self.table[hash_index] = current.next
+                else:
+                    prev.next = current.next
+                return True
+            prev = current
+            current = current.next
+        
+        return False
+    
+    def display(self):
+        for index, item in enumerate(self.table):
+            print(f"Index {index}:", end=" ")
+            current = item
+            while current is not None:
+                print(f"({current.key}, {current.value})", end=" -> ")
+                current = current.next
+            print("None")
+
+# Example usage
+hash_table = HashTable(10)
+
+hash_table.insert(1, 'A')
+hash_table.insert(11, 'B')
+hash_table.insert(21, 'C')
+
+print("Hash Table after Insert operations:")
+hash_table.display()
+
+print("Search operation for key 11:", hash_table.search(11))
+
+hash_table.delete(11)
+
+print("Hash Table after Delete operation:")
+hash_table.display()
+```
+
+## Output
+
+```markdown
+Hash Table after Insert operations:
+Index 0: None
+Index 1: (1, 'A') -> (11, 'B') -> (21, 'C') -> None
+Index 2: None
+Index 3: None
+Index 4: None
+Index 5: None
+Index 6: None
+Index 7: None
+Index 8: None
+Index 9: None
+
+Search operation for key 11: B
+
+Hash Table after Delete operation:
+Index 0: None
+Index 1: (1, 'A') -> (21, 'C') -> None
+Index 2: None
+Index 3: None
+Index 4: None
+Index 5: None
+Index 6: None
+Index 7: None
+Index 8: None
+Index 9: None
+```
+
+## Complexity Analysis
+
+- **Insertion**: Average case O(1), Worst case O(n) when many elements hash to the same slot.
+- **Search**: Average case O(1), Worst case O(n) when many elements hash to the same slot.
+- **Deletion**: Average case O(1), Worst case O(n) when many elements hash to the same slot.
\ No newline at end of file

From 0699376c4b30dbe5c767c58f184a58e2ecdb6674 Mon Sep 17 00:00:00 2001
From: Mangalya Phaye <141892171+mdphaye@users.noreply.github.com>
Date: Tue, 4 Jun 2024 11:07:11 +0530
Subject: [PATCH 39/76] Rename Queues.md to queues.md

---
 contrib/ds-algorithms/{Queues.md => queues.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/ds-algorithms/{Queues.md => queues.md} (100%)

diff --git a/contrib/ds-algorithms/Queues.md b/contrib/ds-algorithms/queues.md
similarity index 100%
rename from contrib/ds-algorithms/Queues.md
rename to contrib/ds-algorithms/queues.md

From a2f8b49b1e77b1d4d9fcc376509e401955b468b7 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 15:47:49 +0530
Subject: [PATCH 40/76] Update match_case_statement.md

Added introduction and syntax
---
 .../advanced-python/match_case_statement.md   | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index e69de29..d4ad861 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -0,0 +1,22 @@
+# Match Case Statements
+## Introduction
+Match and case statements are introduced in Python 3.10 for structural pattern matching of patterns with associated actions. It offers more readible and
+cleaniness to the code as opposed to the traditional `if-else` statements. They also have destructuring, pattern matching and checks for specific properties in
+addition to the traditional `switch-case` statements in other languages, which makes them more versatile.
+
+## Syntax
+```
+match <statement>:
+    case <pattern_1>:
+        <do_task_1>
+    case <pattern_2>:
+        <do_task_2>
+    case _:
+        <do_task_wildcard>
+```
+A match statement takes a statement which compares it to the various cases and their patterns. If any of the pattern is matched successively, the task is performed accordingly. If an exact match is not confirmed, the last case, a wildcard `_`, if provided, will be used as the matching case.
+
+## Pattern Matching
+As discussed earlier, match case statements use pattern matching where the patterns consist of sequences, mappings, primitive data types as well as class instances. The structural pattern matching uses declarative approach and it nexplicitly states the conditions for the patterns to match with the data.
+
+### Patterns with a Literal

From f0c59b288c5e5877eb1f6d69a7f995cbdf08f2f9 Mon Sep 17 00:00:00 2001
From: mankalavaishnavi <mankalavaishnavi2004@gmail.com>
Date: Tue, 4 Jun 2024 15:58:52 +0530
Subject: [PATCH 41/76] Filter definition , syntax is done

---
 contrib/advanced-python/filter-function.md | 86 ++++++++++++++++++++++
 contrib/advanced-python/index.md           |  2 +
 contrib/advanced-python/reduce-function.md | 72 ++++++++++++++++++
 3 files changed, 160 insertions(+)
 create mode 100644 contrib/advanced-python/filter-function.md
 create mode 100644 contrib/advanced-python/reduce-function.md

diff --git a/contrib/advanced-python/filter-function.md b/contrib/advanced-python/filter-function.md
new file mode 100644
index 0000000..cbf9463
--- /dev/null
+++ b/contrib/advanced-python/filter-function.md
@@ -0,0 +1,86 @@
+# Filter Function
+
+## Definition
+The filter function is a built-in Python function used for constructing an iterator from elements of an iterable for which a function returns true.
+
+**Syntax**:
+ ```python
+filter(function, iterable)
+```
+**Parameters**:<br>
+*function*: A function that tests if each element of an iterable returns True or False.<br>
+*iterable*: An iterable like sets, lists, tuples, etc., whose elements are to be filtered.<br>
+*Returns* : An iterator that is already filtered.
+
+## Basic Usage
+**Example 1: Filtering a List of Numbers**:
+```python
+# Define a function that returns True for even numbers
+def is_even(n):
+    return n % 2 == 0
+
+numbers = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+even_numbers = filter(is_even, numbers)
+
+# Convert the filter object to a list
+print(list(even_numbers))  # Output: [2, 4, 6, 8, 10]
+```
+
+**Example 2: Filtering with a Lambda Function**:
+```python
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+odd_numbers = filter(lambda x: x % 2 != 0, numbers)
+
+print(list(odd_numbers))  # Output: [1, 3, 5, 7, 9]
+```
+
+**Example 3: Filtering Strings**:
+```python
+words = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape" , "python"]
+long_words = filter(lambda word: len(word) > 5, words)
+
+print(list(long_words))  # Output: ['banana', 'cherry', 'elderberry', 'python']
+```
+
+## Advanced Usage
+**Example 4: Filtering Objects with Attributes**:
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+people = [
+    Person("Alice", 30),
+    Person("Bob", 15),
+    Person("Charlie", 25),
+    Person("David", 35)
+]
+
+adults = filter(lambda person: person.age >= 18, people)
+adult_names = map(lambda person: person.name, adults)
+
+print(list(adult_names))  # Output: ['Alice', 'Charlie', 'David']
+```
+
+**Example 5: Using None as the Function**:
+```python
+numbers = [0, 1, 2, 3, 0, 4, 0, 5]
+non_zero_numbers = filter(None, numbers)
+
+print(list(non_zero_numbers))  # Output: [1, 2, 3, 4, 5]
+```
+**NOTE**: When None is passed as the function, filter removes all items that are false.
+
+## Time Complexity:
+- The time complexity of filter() depends on two factors:
+    1. The time complexity of the filtering function (the one you provide as an argument).
+    2. The size of the iterable being filtered.
+- If the filtering function has a constant time complexity (e.g., O(1)), the overall time complexity of filter() is   linear (O(n)), where ‘n’ is the number of elements in the iterable.
+
+## Space Complexity:
+- The space complexity of filter() is also influenced by the filtering function and the size of the iterable.
+- Since filter() returns an iterator, it doesn’t create a new list in memory. Instead, it generates filtered elements on-the-fly as you iterate over it. Therefore, the space complexity is O(1).
+
+## Conclusion:
+Python’s filter() allows you to perform filtering operations on iterables. This kind of operation consists of applying a Boolean function to the items in an iterable and keeping only those values for which the function returns a true result. In general, you can use filter() to process existing iterables and produce new iterables containing the values that you currently need.Both versions of Python support filter(), but Python 3’s approach is more memory-efficient due to the use of iterators.
\ No newline at end of file
diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index b31544e..5d6a0b6 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,3 +10,5 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
+- [Filter](filter-function.md)
+- [Reduce](reduce-function.md)
\ No newline at end of file
diff --git a/contrib/advanced-python/reduce-function.md b/contrib/advanced-python/reduce-function.md
new file mode 100644
index 0000000..5c0c81b
--- /dev/null
+++ b/contrib/advanced-python/reduce-function.md
@@ -0,0 +1,72 @@
+# Reduce Function
+
+## Definition:
+The reduce() function is part of the functools module and is used to apply a binary function (a function that takes two arguments) cumulatively to the items of an iterable (e.g., a list, tuple, or string). It reduces the iterable to a single value by successively combining elements.
+
+**Syntax**:
+```python
+from functools import reduce
+reduce(function, iterable, initial=None)
+```
+**Parameters**:<br>
+*function* : The binary function to apply. It takes two arguments and returns a single value.<br>
+*iterable* : The sequence of elements to process.<br>
+*initial (optional)*: An initial value. If provided, the function is applied to the initial value and the first element of the iterable. Otherwise, the first two elements are used as the initial values.
+
+## Working:
+- Intially , first two elements of iterable are picked and the result is obtained.
+- Next step is to apply the same function to the previously attained result and the number just succeeding the second element and the result is again stored.
+- This process continues till no more elements are left in the container.
+- The final returned result is returned and printed on console.
+
+## Examples:
+
+**Example 1:**
+```python
+numbers = [1, 2, 3, 4, 10]
+total = reduce(lambda x, y: x + y, numbers)
+print(total)  # Output: 20
+```
+**Example 2:**
+```python
+numbers = [11, 7, 8, 20, 1]
+max_value = reduce(lambda x, y: x if x > y else y, numbers)
+print(max_value)  # Output: 20
+```
+**Example 3:**
+```python
+# Importing reduce function from functools  
+from functools import reduce  
+  
+# Creating a list  
+my_list = [10, 20, 30, 40, 50]  
+  
+# Calculating the product of the numbers in my_list  
+# using reduce and lambda functions together  
+product = reduce(lambda x, y: x * y, my_list)  
+  
+# Printing output  
+print(f"Product = {product}") # Output : Product = 12000000
+```
+
+## Difference Between reduce() and accumulate():
+- **Behavior:**
+    - reduce() stores intermediate results and only returns the final summation value.
+    - accumulate() returns an iterator containing all intermediate results. The last value in the iterator is the summation value of the list.
+
+- **Use Cases:**
+    - Use reduce() when you need a single result (e.g., total sum, product) from the iterable.
+    - Use accumulate() when you want to access intermediate results during the reduction process.
+
+- **Initial Value:**
+    - reduce() allows an optional initial value.
+    - accumulate() also accepts an optional initial value since Python 3.8.
+
+- **Order of Arguments:**
+    - reduce() takes the function first, followed by the iterable.
+    - accumulate() takes the iterable first, followed by the function.
+
+## Conclusion:
+Python's Reduce function enables us to apply reduction operations to iterables using lambda and callable functions. A 
+function called reduce() reduces the elements of an iterable to a single cumulative value. The reduce function in 
+Python solves various straightforward issues, including adding and multiplying iterables of numbers.
\ No newline at end of file

From 55717a47dee55e6d62aa161e52840b7075dc0689 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 16:48:03 +0530
Subject: [PATCH 42/76] Update match_case_statement.md

Added patterns with a literal section
---
 .../advanced-python/match_case_statement.md   | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index d4ad861..691d23b 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -20,3 +20,60 @@ A match statement takes a statement which compares it to the various cases and t
 As discussed earlier, match case statements use pattern matching where the patterns consist of sequences, mappings, primitive data types as well as class instances. The structural pattern matching uses declarative approach and it nexplicitly states the conditions for the patterns to match with the data.
 
 ### Patterns with a Literal
+#### Generic Case
+`sample text` is passed as a literal in the `match` block. There are two cases and a wildcard case mentioned.
+```python
+match 'sample text':
+    case 'sample text':
+        print('sample text')
+    case 'sample':
+        print('sample')
+    case _:
+        print('None found')
+```
+The `sample text` case is satisfied as it matches with the literal `sample text` described in the `match` block.
+
+O/P:
+```
+sample text
+```
+
+#### Using OR
+Taking another example, `|` can be used as OR to include multiple patterns in a single case statement where the multiple patterns all lead to a similar task.
+
+The below code snippets can be used interchangebly and generate the similar output. The latter is more consive and readible.
+```python
+match 'e':
+    case 'a':
+        print('vowel')
+    case 'e':
+        print('vowel')
+    case 'i':
+        print('vowel')
+    case 'o':
+        print('vowel')
+    case 'u':
+        print('vowel')
+    case _:
+        print('consonant')
+```
+```python
+match 'e':
+    case 'a' | 'e' | 'i' | 'o' | 'u':
+        print('vowel')
+    case _:
+        print('consonant')
+```
+O/P:
+```
+vowel
+```
+
+#### Without wildcard
+When in a `match` block, there is no wildcard case present there are be two cases of match being present or not. If the match doesn't exist, the behaviour is a no-op.
+```python
+match 'c':
+    case 'a' | 'e' | 'i' | 'o' | 'u':
+        print('vowel')
+```
+The output will be blank as a no-op occurs.

From 43455d1b56fdbd35a291999f94303373c1c5ee59 Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <yogeshv1603@gmail.com>
Date: Tue, 4 Jun 2024 17:08:51 +0530
Subject: [PATCH 43/76] Added two-pointer-technique.md and updated index.md

---
 contrib/ds-algorithms/index.md                |   1 +
 .../ds-algorithms/two-pointer-technique.md    | 134 ++++++++++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 contrib/ds-algorithms/two-pointer-technique.md

diff --git a/contrib/ds-algorithms/index.md b/contrib/ds-algorithms/index.md
index 1d7293b..52293d9 100644
--- a/contrib/ds-algorithms/index.md
+++ b/contrib/ds-algorithms/index.md
@@ -13,3 +13,4 @@
 - [Stacks in Python](stacks.md)
 - [Sliding Window Technique](sliding-window.md)
 - [Trie](trie.md)
+- [Two Pointer Technique](two-pointer-technique.md)
diff --git a/contrib/ds-algorithms/two-pointer-technique.md b/contrib/ds-algorithms/two-pointer-technique.md
new file mode 100644
index 0000000..cec588f
--- /dev/null
+++ b/contrib/ds-algorithms/two-pointer-technique.md
@@ -0,0 +1,134 @@
+# Two-Pointer Technique
+
+---
+
+- The two-pointer technique is a popular algorithmic strategy used to solve various problems efficiently. This technique involves using two pointers (or indices) to traverse through data structures such as arrays or linked lists. 
+- The pointers can move in different directions, allowing for efficient processing of elements to achieve the desired results.
+
+## Common Use Cases
+
+1. **Finding pairs in a sorted array that sum to a target**: One pointer starts at the beginning and the other at the end.
+2. **Reversing a linked list**: One pointer starts at the head, and the other at the next node, progressing through the list.
+3. **Removing duplicates from a sorted array**: One pointer keeps track of the unique elements, and the other traverses the array.
+4. **Merging two sorted arrays**: Two pointers are used to iterate through the arrays and merge them.
+
+## Example 1: Finding Pairs with a Given Sum
+
+### Problem Statement
+
+Given a sorted array of integers and a target sum, find all pairs in the array that sum up to the target.
+
+### Approach
+
+1. Initialize two pointers: one at the beginning (`left`) and one at the end (`right`) of the array.
+2. Calculate the sum of the elements at the `left` and `right` pointers.
+3. If the sum is equal to the target, record the pair and move both pointers inward.
+4. If the sum is less than the target, move the `left` pointer to the right to increase the sum.
+5. If the sum is greater than the target, move the `right` pointer to the left to decrease the sum.
+6. Repeat the process until the `left` pointer is not less than the `right` pointer.
+
+### Example Code
+
+```python
+def find_pairs_with_sum(arr, target):
+    left = 0
+    right = len(arr) - 1
+    pairs = []
+
+    while left < right:
+        current_sum = arr[left] + arr[right]
+        
+        if current_sum == target:
+            pairs.append((arr[left], arr[right]))
+            left += 1
+            right -= 1
+        elif current_sum < target:
+            left += 1
+        else:
+            right -= 1
+    
+    return pairs
+
+# Example usage
+arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+target = 10
+result = find_pairs_with_sum(arr, target)
+print("Pairs with sum", target, "are:", result)
+ ```
+
+## Example 2: Removing Duplicates from a Sorted Array
+
+### Problem Statement
+Given a sorted array, remove the duplicates in place such that each element appears only once and return the new length of the array.
+
+### Approach
+1. If the array is empty, return 0.
+2. Initialize a slow pointer at the beginning of the array.
+3. Use a fast pointer to traverse through the array.
+4. Whenever the element at the fast pointer is different from the element at the slow pointer, increment the slow pointer and update the element at the slow pointer with the element at the fast pointer.
+5. Continue this process until the fast pointer reaches the end of the array.
+6. The slow pointer will indicate the position of the last unique element.
+
+### Example Code
+
+```python
+def remove_duplicates(arr):
+    if not arr:
+        return 0
+    
+    slow = 0
+
+    for fast in range(1, len(arr)):
+        if arr[fast] != arr[slow]:
+            slow += 1
+            arr[slow] = arr[fast]
+    
+    return slow + 1
+
+# Example usage
+arr = [1, 1, 2, 2, 3, 4, 4, 5]
+new_length = remove_duplicates(arr)
+print("Array after removing duplicates:", arr[:new_length])
+print("New length of array:", new_length)
+```
+# Advantages of the Two-Pointer Technique
+
+Here are some key benefits of using the two-pointer technique:
+
+## 1. **Improved Time Complexity**
+
+It often reduces the time complexity from O(n^2) to O(n), making it significantly faster for many problems.
+
+### Example
+- **Finding pairs with a given sum**: Efficiently finds pairs in O(n) time.
+
+## 2. **Simplicity**
+
+The implementation is straightforward, using basic operations like incrementing or decrementing pointers.
+
+### Example
+- **Removing duplicates from a sorted array**: Easy to implement and understand.
+
+## 3. **In-Place Solutions**
+
+Many problems can be solved in place, requiring no extra space beyond the input data.
+
+### Example
+- **Reversing a linked list**: Adjusts pointers within the existing nodes.
+
+## 4. **Versatility**
+
+Applicable to a wide range of problems, from arrays and strings to linked lists.
+
+### Example
+- **Merging two sorted arrays**: Efficiently merges using two pointers.
+
+## 5. **Efficiency**
+
+Minimizes redundant operations and enhances performance, especially with large data sets.
+
+### Example
+- **Partitioning problems**: Efficiently partitions elements with minimal operations.
+
+
+These advantages make the two-pointer technique a valuable approach for many algorithmic challenges.

From a4c93b95adbca63d75c05d5754ea81e540cba34c Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <103316955+Yogeshkarma@users.noreply.github.com>
Date: Tue, 4 Jun 2024 17:13:27 +0530
Subject: [PATCH 44/76] Update two-pointer-technique.md

Removed the footer line
---
 contrib/ds-algorithms/two-pointer-technique.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/contrib/ds-algorithms/two-pointer-technique.md b/contrib/ds-algorithms/two-pointer-technique.md
index cec588f..6b8720a 100644
--- a/contrib/ds-algorithms/two-pointer-technique.md
+++ b/contrib/ds-algorithms/two-pointer-technique.md
@@ -130,5 +130,3 @@ Minimizes redundant operations and enhances performance, especially with large d
 ### Example
 - **Partitioning problems**: Efficiently partitions elements with minimal operations.
 
-
-These advantages make the two-pointer technique a valuable approach for many algorithmic challenges.

From 5f57b24ac03006216a366219e09ea0566e231ab8 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 17:44:13 +0530
Subject: [PATCH 45/76] Update match_case_statement.md

Added two more sections. Patterns with a literal and a variable, and patterns with classes.
---
 .../advanced-python/match_case_statement.md   | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index 691d23b..57f6bfb 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -77,3 +77,86 @@ match 'c':
         print('vowel')
 ```
 The output will be blank as a no-op occurs.
+
+### Patterns with a Literal and a Variable
+Pattern matching can be done by unpacking the assignments and also bind variables with it.
+```python
+def get_names(names: str) -> None:
+    match names:
+        case ('Bob', y):
+            print(f'Hello {y}')
+        case (x, 'John'):
+            print(f'Hello {x}')
+        case (x, y):
+            print(f'Hello {x} and {y}')
+        case _:
+            print('Invalid')
+```
+Here, the `names` is a tuple that contains two names. The `match` block unpacks the tuple and binds `x` and `y` based on the patterns. A wildcard case prints `Invalid` if the condition is not satisfied.
+
+O/P:
+
+In this example, the above code snippet with the parameter `names` as below and the respective output.
+```
+>>> get_names(('Bob', 'Max'))
+Hello Max
+
+>>> get_names(('Rob', 'John'))
+Hello Rob
+
+>>> get_names(('Rob', 'Max'))
+Hello Rob and Max
+
+>>> get_names(('Rob', 'Max', 'Bob'))
+Invalid
+```
+
+### Patterns with Classes
+Class structures can be used in `match` block for pattern matching. The class members can also be binded with a variable to perform certain operations. For the class structure:
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+```
+The match case example illustrates the generic working as well as the binding of variables with the class members.
+```python
+def get_class(cls: Person) -> None:
+    match cls:
+        case Person(name='Bob', age=18):
+            print('Hello Bob with age 18')
+        case Person(name='Max', age=y):
+            print(f'Age is {y}')
+        case Person(name=x, age=18):
+            print(f'Name is {x}')
+        case Person(name=x, age=y):
+            print(f'Name and age is {x} and {y}')
+        case _:
+            print('Invalid')
+```
+O/P:
+```
+>>> get_class(Person('Bob', 18))
+Hello Bob with age 18
+
+>>> get_class(Person('Max', 21))
+Age is 21
+
+>>> get_class(Person('Rob', 18))
+Name is Rob
+
+>>> get_class(Person('Rob', 21))
+Name and age is Rob and 21
+```
+Now, if a new class is introduced in the above code snippet like below.
+```python
+class Pet:
+    def __init__(self, name, animal):
+        self.name = name
+        self.animal = animal
+```
+The patterns will not match the cases and will trigger the wildcard case for the original code snippet above with `get_class` function.
+```
+>>> get_class(Pet('Tommy', 'Dog'))
+Invalid
+```

From e5c88286d5b72b0e0e51e4f1c889544b41c91ef9 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 18:02:50 +0530
Subject: [PATCH 46/76] Update match_case_statement.md

Added remaining topic headings
---
 contrib/advanced-python/match_case_statement.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index 57f6bfb..6941d98 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -160,3 +160,14 @@ The patterns will not match the cases and will trigger the wildcard case for the
 >>> get_class(Pet('Tommy', 'Dog'))
 Invalid
 ```
+
+### Nested Patterns
+
+### Complex Patterns
+#### Wildcard
+
+#### Guard
+
+## Summary
+
+## Further Reading

From ffcc45ad986b70a5b1b39cc515bb7e7230db3c4d Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 18:28:39 +0530
Subject: [PATCH 47/76] Update match_case_statement.md

Added nested patterns
---
 .../advanced-python/match_case_statement.md   | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index 6941d98..22eeef9 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -162,6 +162,33 @@ Invalid
 ```
 
 ### Nested Patterns
+The patterns can be nested via various means. It can include the mix of the patterns mentioned earlier or can be symmetrical across. A basic of the nested pattern of a list with Patterns with a Literal and Variable is taken. Classes and Iterables can laso be included.
+```python
+def get_points(points: list) -> None:
+    match points:
+        case []:
+            print('Empty')
+        case [x]:
+            print(f'One point {x}')
+        case [x, y]:
+            print(f'Two points {x} and {y}')
+        case _:
+            print('More than two points')
+```
+O/P:
+```
+>>> get_points([])
+Empty
+
+>>> get_points([1])
+One point 1
+
+>>> get_points([1, 2])
+Two points 1 and 2
+
+>>> get_points([1, 2, 3])
+More than two points
+```
 
 ### Complex Patterns
 #### Wildcard

From d345d0339f7a2bd5eea818f5a42bc4e0c5d9f5f7 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 19:14:09 +0530
Subject: [PATCH 48/76] Update match_case_statement.md

Added the content to remaining sections
---
 .../advanced-python/match_case_statement.md   | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index 22eeef9..cd7bc64 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -191,10 +191,60 @@ More than two points
 ```
 
 ### Complex Patterns
+Complex patterns are also supported in the pattern matching sequence. The complex does not mean complex numbers but rather the structure which makes the readibility to seem complex.
+
 #### Wildcard
+The wildcard used till now are in the form of `case _` where the wildcard case is used if no match is found. Furthermore, the wildcard `_` can also be used as a placeholder in complex patterns.
+
+```python
+def wildcard(value: tuple) -> None:
+    match value:
+        case ('Bob', age, 'Mechanic'):
+            print(f'Bob is mechanic of age {age}')
+        case ('Bob', age, _):
+            print(f'Bob is not a mechanic of age {age}')
+```
+O/P:
+
+The value in the above snippet is a tuple with `(Name, Age, Job)`. If the job is Mechanic and the name is Bob, the first case is triggered. But if the job is different and not a mechanic, then the other case is triggered with the wildcard.
+```
+>>> wildcard(('Bob', 18, 'Mechanic'))
+Bob is mechanic of age 18
+
+>>> wildcard(('Bob', 21, 'Engineer'))
+Bob is not a mechanic of age 21
+```
 
 #### Guard
+A `guard` is when an `if` is added to a pattern. The evaluation depends on the truth value of the guard.
+
+`nums` is the tuple which contains two integers. A guard is the first case where it checks whether the first number is greater or equal to the second number in the tuple. If it is false, then it moves to the second case, where it concludes that the first number is smaller than the second number.
+```python
+def guard(nums: tuple) -> None:
+    match nums:
+        case (x, y) if x >= y:
+            print(f'{x} is greater or equal than {y}')
+        case (x, y):
+            print(f'{x} is smaller than {y}')
+        case _:
+            print('Invalid')
+```
+O/P:
+```
+>>> guard((1, 2))
+1 is smaller than 2
+
+>>> guard((2, 1))
+2 is greater or equal than 1
+
+>>> guard((1, 1))
+1 is greater or equal than 1
+```
 
 ## Summary
+The match case statements provide an elegant and readible format to perform operations on pattern matching as compared to `if-else` statements. They are also more versatile as they provide additional functionalities on the pattern matching operations like unpacking, class matching, iterables and iterators. It can also use positional arguments for checking the patterns. They provide a powerful and concise way to handle multiple conditions and perform pattern matching
 
 ## Further Reading
+- [Python Match Case Statement - GeeksForGeeks](https://www.geeksforgeeks.org/python-match-case-statement/)
+- [PEP 634 – Structural Pattern Matching: Specification](https://peps.python.org/pep-0634/)
+- [PEP 636 – Structural Pattern Matching: Tutorial](https://peps.python.org/pep-0636/)

From fe4ce4a34df72c800d12c624385069b27b689d11 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Tue, 4 Jun 2024 19:16:29 +0530
Subject: [PATCH 49/76] Update match_case_statement.md

Added further reading topic summary
---
 contrib/advanced-python/match_case_statement.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match_case_statement.md
index cd7bc64..b617f7a 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match_case_statement.md
@@ -245,6 +245,8 @@ O/P:
 The match case statements provide an elegant and readible format to perform operations on pattern matching as compared to `if-else` statements. They are also more versatile as they provide additional functionalities on the pattern matching operations like unpacking, class matching, iterables and iterators. It can also use positional arguments for checking the patterns. They provide a powerful and concise way to handle multiple conditions and perform pattern matching
 
 ## Further Reading
+This article provides a brief introduction to the match case statements and the overview on the pattern matching operations. To know more, the below articles can be used for in-depth understanding of the topic.
+
 - [Python Match Case Statement - GeeksForGeeks](https://www.geeksforgeeks.org/python-match-case-statement/)
 - [PEP 634 – Structural Pattern Matching: Specification](https://peps.python.org/pep-0634/)
 - [PEP 636 – Structural Pattern Matching: Tutorial](https://peps.python.org/pep-0636/)

From b3c31ea9499b068a41c10d2a444edb3c439eae5c Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <yogeshv1603@gmail.com>
Date: Tue, 4 Jun 2024 19:57:15 +0530
Subject: [PATCH 50/76] added Universal-Functions.md and updated the index.md

---
 contrib/numpy/Universal-Functions.md | 130 +++++++++++++++++++++++++++
 contrib/numpy/index.md               |   1 +
 2 files changed, 131 insertions(+)
 create mode 100644 contrib/numpy/Universal-Functions.md

diff --git a/contrib/numpy/Universal-Functions.md b/contrib/numpy/Universal-Functions.md
new file mode 100644
index 0000000..a06b0d1
--- /dev/null
+++ b/contrib/numpy/Universal-Functions.md
@@ -0,0 +1,130 @@
+# Universal functions (ufunc)
+
+---
+
+A `ufunc`, short for "`universal function`," is a fundamental concept in NumPy, a powerful library for numerical computing in Python. Universal functions are highly optimized, element-wise functions designed to perform operations on data stored in NumPy arrays. 
+
+
+
+## Uses of Ufuncs in NumPy
+
+Universal functions (ufuncs) in NumPy provide a wide range of functionalities for efficient and powerful numerical computations. Below is a detailed explanation of their uses:
+
+### 1. **Element-wise Operations**
+Ufuncs perform operations on each element of the arrays independently.
+
+```python
+import numpy as np
+
+A = np.array([1, 2, 3, 4])
+B = np.array([5, 6, 7, 8])
+
+# Element-wise addition
+np.add(A, B)  # Output: array([ 6,  8, 10, 12])
+```
+
+### 2. **Broadcasting**
+Ufuncs support broadcasting, allowing operations on arrays with different shapes, making it possible to perform operations without explicitly reshaping arrays.
+
+```python
+C = np.array([1, 2, 3])
+D = np.array([[1], [2], [3]])
+
+# Broadcasting addition
+np.add(C, D)  # Output: array([[2, 3, 4], [3, 4, 5], [4, 5, 6]])
+```
+
+### 3. **Vectorization**
+Ufuncs are vectorized, meaning they are implemented in low-level C code, allowing for fast execution and avoiding the overhead of Python loops.
+
+```python
+# Vectorized square root
+np.sqrt(A)  # Output: array([1., 1.41421356, 1.73205081, 2.])
+```
+
+### 4. **Type Flexibility**
+Ufuncs handle various data types and perform automatic type casting as needed.
+
+```python
+E = np.array([1.0, 2.0, 3.0])
+F = np.array([4, 5, 6])
+
+# Addition with type casting
+np.add(E, F)  # Output: array([5., 7., 9.])
+```
+
+### 5. **Reduction Operations**
+Ufuncs support reduction operations, such as summing all elements of an array or finding the product of all elements.
+
+```python
+# Summing all elements
+np.add.reduce(A)  # Output: 10
+
+# Product of all elements
+np.multiply.reduce(A)  # Output: 24
+```
+
+### 6. **Accumulation Operations**
+Ufuncs can perform accumulation operations, which keep a running tally of the computation.
+
+```python
+# Cumulative sum
+np.add.accumulate(A)  # Output: array([ 1,  3,  6, 10])
+```
+
+### 7. **Reduceat Operations**
+Ufuncs can perform segmented reductions using the `reduceat` method, which applies the ufunc at specified intervals.
+
+```python
+G = np.array([0, 1, 2, 3, 4, 5, 6, 7])
+indices = [0, 2, 5]
+np.add.reduceat(G, indices)  # Output: array([ 1,  9, 18])
+```
+
+### 8. **Outer Product**
+Ufuncs can compute the outer product of two arrays, producing a matrix where each element is the result of applying the ufunc to each pair of elements from the input arrays.
+
+```python
+# Outer product
+np.multiply.outer([1, 2, 3], [4, 5, 6])  
+# Output: array([[ 4,  5,  6],
+#                [ 8, 10, 12],
+#                [12, 15, 18]])
+```
+
+### 9. **Out Parameter**
+Ufuncs can use the `out` parameter to store results in a pre-allocated array, saving memory and improving performance.
+
+```python
+result = np.empty_like(A)
+np.multiply(A, B, out=result)  # Output: array([ 5, 12, 21, 32])
+```
+
+# Create Your Own Ufunc
+
+You can create custom ufuncs for specific needs using np.frompyfunc or np.vectorize, allowing Python functions to behave like ufuncs.
+
+Here, we are using `frompyfunc()` which takes three argument:
+
+1. function - the name of the function.
+2. inputs - the number of input  (arrays).
+3. outputs - the number of output arrays.
+
+```python
+def my_add(x, y):
+    return x + y
+
+my_add_ufunc = np.frompyfunc(my_add, 2, 1)
+my_add_ufunc(A, B)  # Output: array([ 6,  8, 10, 12], dtype=object)
+```
+# Some Common Ufunc are
+
+Here are some commonly used ufuncs in NumPy:
+
+- **Arithmetic**: `np.add`, `np.subtract`, `np.multiply`, `np.divide`
+- **Trigonometric**: `np.sin`, `np.cos`, `np.tan`
+- **Exponential and Logarithmic**: `np.exp`, `np.log`, `np.log10`
+- **Comparison**: `np.maximum`, `np.minimum`, `np.greater`, `np.less`
+- **Logical**: `np.logical_and`, `np.logical_or`, `np.logical_not`
+
+For more such Ufunc, address to  [Universal functions (ufunc) — NumPy](https://numpy.org/doc/stable/reference/ufuncs.html)
\ No newline at end of file
diff --git a/contrib/numpy/index.md b/contrib/numpy/index.md
index 50e8046..2b0c357 100644
--- a/contrib/numpy/index.md
+++ b/contrib/numpy/index.md
@@ -11,3 +11,4 @@
 - [Sorting NumPy Arrays](sorting-array.md)
 - [NumPy Array Iteration](array-iteration.md)
 - [Concatenation of Arrays](concatenation-of-arrays.md)
+- [Universal Functions (Ufunc)](Universal-Functions.md)

From 0eefe006fadf5646c0be4c8283743ae6051ea5c0 Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <103316955+Yogeshkarma@users.noreply.github.com>
Date: Tue, 4 Jun 2024 20:07:56 +0530
Subject: [PATCH 51/76] Delete contrib/numpy/Universal-Functions.md

for creating two PR separately
---
 contrib/numpy/Universal-Functions.md | 130 ---------------------------
 1 file changed, 130 deletions(-)
 delete mode 100644 contrib/numpy/Universal-Functions.md

diff --git a/contrib/numpy/Universal-Functions.md b/contrib/numpy/Universal-Functions.md
deleted file mode 100644
index a06b0d1..0000000
--- a/contrib/numpy/Universal-Functions.md
+++ /dev/null
@@ -1,130 +0,0 @@
-# Universal functions (ufunc)
-
----
-
-A `ufunc`, short for "`universal function`," is a fundamental concept in NumPy, a powerful library for numerical computing in Python. Universal functions are highly optimized, element-wise functions designed to perform operations on data stored in NumPy arrays. 
-
-
-
-## Uses of Ufuncs in NumPy
-
-Universal functions (ufuncs) in NumPy provide a wide range of functionalities for efficient and powerful numerical computations. Below is a detailed explanation of their uses:
-
-### 1. **Element-wise Operations**
-Ufuncs perform operations on each element of the arrays independently.
-
-```python
-import numpy as np
-
-A = np.array([1, 2, 3, 4])
-B = np.array([5, 6, 7, 8])
-
-# Element-wise addition
-np.add(A, B)  # Output: array([ 6,  8, 10, 12])
-```
-
-### 2. **Broadcasting**
-Ufuncs support broadcasting, allowing operations on arrays with different shapes, making it possible to perform operations without explicitly reshaping arrays.
-
-```python
-C = np.array([1, 2, 3])
-D = np.array([[1], [2], [3]])
-
-# Broadcasting addition
-np.add(C, D)  # Output: array([[2, 3, 4], [3, 4, 5], [4, 5, 6]])
-```
-
-### 3. **Vectorization**
-Ufuncs are vectorized, meaning they are implemented in low-level C code, allowing for fast execution and avoiding the overhead of Python loops.
-
-```python
-# Vectorized square root
-np.sqrt(A)  # Output: array([1., 1.41421356, 1.73205081, 2.])
-```
-
-### 4. **Type Flexibility**
-Ufuncs handle various data types and perform automatic type casting as needed.
-
-```python
-E = np.array([1.0, 2.0, 3.0])
-F = np.array([4, 5, 6])
-
-# Addition with type casting
-np.add(E, F)  # Output: array([5., 7., 9.])
-```
-
-### 5. **Reduction Operations**
-Ufuncs support reduction operations, such as summing all elements of an array or finding the product of all elements.
-
-```python
-# Summing all elements
-np.add.reduce(A)  # Output: 10
-
-# Product of all elements
-np.multiply.reduce(A)  # Output: 24
-```
-
-### 6. **Accumulation Operations**
-Ufuncs can perform accumulation operations, which keep a running tally of the computation.
-
-```python
-# Cumulative sum
-np.add.accumulate(A)  # Output: array([ 1,  3,  6, 10])
-```
-
-### 7. **Reduceat Operations**
-Ufuncs can perform segmented reductions using the `reduceat` method, which applies the ufunc at specified intervals.
-
-```python
-G = np.array([0, 1, 2, 3, 4, 5, 6, 7])
-indices = [0, 2, 5]
-np.add.reduceat(G, indices)  # Output: array([ 1,  9, 18])
-```
-
-### 8. **Outer Product**
-Ufuncs can compute the outer product of two arrays, producing a matrix where each element is the result of applying the ufunc to each pair of elements from the input arrays.
-
-```python
-# Outer product
-np.multiply.outer([1, 2, 3], [4, 5, 6])  
-# Output: array([[ 4,  5,  6],
-#                [ 8, 10, 12],
-#                [12, 15, 18]])
-```
-
-### 9. **Out Parameter**
-Ufuncs can use the `out` parameter to store results in a pre-allocated array, saving memory and improving performance.
-
-```python
-result = np.empty_like(A)
-np.multiply(A, B, out=result)  # Output: array([ 5, 12, 21, 32])
-```
-
-# Create Your Own Ufunc
-
-You can create custom ufuncs for specific needs using np.frompyfunc or np.vectorize, allowing Python functions to behave like ufuncs.
-
-Here, we are using `frompyfunc()` which takes three argument:
-
-1. function - the name of the function.
-2. inputs - the number of input  (arrays).
-3. outputs - the number of output arrays.
-
-```python
-def my_add(x, y):
-    return x + y
-
-my_add_ufunc = np.frompyfunc(my_add, 2, 1)
-my_add_ufunc(A, B)  # Output: array([ 6,  8, 10, 12], dtype=object)
-```
-# Some Common Ufunc are
-
-Here are some commonly used ufuncs in NumPy:
-
-- **Arithmetic**: `np.add`, `np.subtract`, `np.multiply`, `np.divide`
-- **Trigonometric**: `np.sin`, `np.cos`, `np.tan`
-- **Exponential and Logarithmic**: `np.exp`, `np.log`, `np.log10`
-- **Comparison**: `np.maximum`, `np.minimum`, `np.greater`, `np.less`
-- **Logical**: `np.logical_and`, `np.logical_or`, `np.logical_not`
-
-For more such Ufunc, address to  [Universal functions (ufunc) — NumPy](https://numpy.org/doc/stable/reference/ufuncs.html)
\ No newline at end of file

From 6b35fb7a8ebcbd423f5e6d4a8f95c39c3550cdfa Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <103316955+Yogeshkarma@users.noreply.github.com>
Date: Tue, 4 Jun 2024 20:08:24 +0530
Subject: [PATCH 52/76] Update index.md

for two different pRs
---
 contrib/numpy/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/numpy/index.md b/contrib/numpy/index.md
index 2b0c357..3caac1d 100644
--- a/contrib/numpy/index.md
+++ b/contrib/numpy/index.md
@@ -11,4 +11,4 @@
 - [Sorting NumPy Arrays](sorting-array.md)
 - [NumPy Array Iteration](array-iteration.md)
 - [Concatenation of Arrays](concatenation-of-arrays.md)
-- [Universal Functions (Ufunc)](Universal-Functions.md)
+

From 4a9287f6f0f57a0f4490f41037e5c7489fe089ff Mon Sep 17 00:00:00 2001
From: Yogesh Vishwakarma <103316955+Yogeshkarma@users.noreply.github.com>
Date: Tue, 4 Jun 2024 20:10:18 +0530
Subject: [PATCH 53/76] Update index.md

---
 contrib/numpy/index.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/contrib/numpy/index.md b/contrib/numpy/index.md
index 3caac1d..50e8046 100644
--- a/contrib/numpy/index.md
+++ b/contrib/numpy/index.md
@@ -11,4 +11,3 @@
 - [Sorting NumPy Arrays](sorting-array.md)
 - [NumPy Array Iteration](array-iteration.md)
 - [Concatenation of Arrays](concatenation-of-arrays.md)
-

From 218c09f481ff14f9bbecd2280561a06c82cd9de6 Mon Sep 17 00:00:00 2001
From: Saimanjari777 <psmanjari777@gmail.com>
Date: Tue, 4 Jun 2024 20:45:53 +0530
Subject: [PATCH 54/76] Update sorting-algorithms.md

I have added radix and counting sort
---
 contrib/ds-algorithms/sorting-algorithms.md | 96 +++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/contrib/ds-algorithms/sorting-algorithms.md b/contrib/ds-algorithms/sorting-algorithms.md
index 2edc265..55367b8 100644
--- a/contrib/ds-algorithms/sorting-algorithms.md
+++ b/contrib/ds-algorithms/sorting-algorithms.md
@@ -465,3 +465,99 @@ print("Sorted array:", arr)  # Output: [1, 2, 3, 5, 8]
  - **Worst Case:** `𝑂(𝑛log𝑛)`. Building the heap takes `𝑂(𝑛)` time, and each of the 𝑛 element extractions takes `𝑂(log𝑛)` time.
  - **Best Case:** `𝑂(𝑛log𝑛)`. Even if the array is already sorted, heap sort will still build the heap and perform the extractions.
  - **Average Case:** `𝑂(𝑛log𝑛)`. Similar to the worst-case, the overall complexity remains `𝑂(𝑛log𝑛)` because each insertion and deletion in a heap takes `𝑂(log𝑛)` time, and these operations are performed 𝑛 times.
+
+ ## 7. Radix Sort
+Radix Sort is a non-comparative integer sorting algorithm that sorts numbers by processing individual digits. It processes digits from the least significant digit (LSD) to the most significant digit (MSD) or vice versa. This algorithm is efficient for sorting numbers with a fixed number of digits.
+
+**Algorithm Overview:**
+- **Digit by Digit sorting:** Radix sort processes the digits of the numbers starting from either the least significant digit (LSD) or the most significant digit (MSD). Typically, LSD is used.
+- **Stable Sort:** A stable sorting algorithm like Counting Sort or Bucket Sort is used as an intermediate sorting technique. Radix Sort relies on this stability to maintain the relative order of numbers with the same digit value.
+- **Multiple passes:**  The algorithm performs multiple passes over the numbers, one for each digit, from the least significant to the most significant.
+
+### Radix Sort Code in Python
+
+```python
+def counting_sort(arr, exp):
+    n = len(arr)
+    output = [0] * n
+    count = [0] * 10
+
+    for i in range(n):
+        index = arr[i] // exp
+        count[index % 10] += 1
+
+    for i in range(1, 10):
+        count[i] += count[i - 1]
+
+    i = n - 1
+    while i >= 0:
+        index = arr[i] // exp
+        output[count[index % 10] - 1] = arr[i]
+        count[index % 10] -= 1
+        i -= 1
+
+    for i in range(n):
+        arr[i] = output[i]
+
+def radix_sort(arr):
+    max_num = max(arr)
+    exp = 1
+    while max_num // exp > 0:
+        counting_sort(arr, exp)
+        exp *= 10
+
+# Example usage
+arr = [170, 45, 75, 90]
+print("Original array:", arr)
+radix_sort(arr)
+print("Sorted array:", arr)
+```
+
+### Complexity Analysis
+ - **Time Complexity:** O(d * (n + k)) for all cases. Radix Sort always processes each digit of every number in the array.
+ - **Space Complexity:** O(n + k). This is due to the space required for:
+- The output array used in Counting Sort, which is of size n.
+- The count array used in Counting Sort, which is of size k.
+
+## 8. Counting Sort
+Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of objects having distinct key values (kind of hashing). Then do some arithmetic to calculate the position of each object in the output sequence. 
+
+**Algorithm Overview:**
+- Convert the input string into a list of characters.
+- Count the occurrence of each character in the list using the collections.Counter() method.
+- Sort the keys of the resulting Counter object to get the unique characters in the list in sorted order.
+- For each character in the sorted list of keys, create a list of repeated characters using the corresponding count from the Counter object.
+- Concatenate the lists of repeated characters to form the sorted output list.
+
+
+### Counting Sort Code in Python using counter method.
+
+```python
+from collections import Counter
+
+def counting_sort(arr):
+	count = Counter(arr)
+	output = []
+	for c in sorted(count.keys()):
+		output +=  * count
+	return output
+
+arr = "geeksforgeeks"
+arr = list(arr)
+arr = counting_sort(arr)
+output = ''.join(arr)
+print("Sorted character array is", output)
+
+```
+### Counting Sort Code in Python using sorted() and reduce():
+
+```python
+from functools import reduce
+string = "geeksforgeeks"
+sorted_str = reduce(lambda x, y: x+y, sorted(string))
+print("Sorted string:", sorted_str)
+```
+
+### Complexity Analysis
+ - **Time Complexity:** O(n+k) for all cases.No matter how the elements are placed in the array, the algorithm goes through n+k times
+ - **Space Complexity:** O(max). Larger the range of elements, larger is the space complexity.

From f7dc61226c88c3f877d473cb71ca4142a5e7cad5 Mon Sep 17 00:00:00 2001
From: Pradnya Gaitonde <116059908+PradnyaGaitonde@users.noreply.github.com>
Date: Wed, 5 Jun 2024 00:33:22 +0530
Subject: [PATCH 55/76] Create Type_Hinting.md

Added Content on Type hinting in python
---
 contrib/advanced-python/Type_Hinting.md | 106 ++++++++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 contrib/advanced-python/Type_Hinting.md

diff --git a/contrib/advanced-python/Type_Hinting.md b/contrib/advanced-python/Type_Hinting.md
new file mode 100644
index 0000000..fcf1e1c
--- /dev/null
+++ b/contrib/advanced-python/Type_Hinting.md
@@ -0,0 +1,106 @@
+# Introduction to Type Hinting in Python
+Type hinting is a feature in Python that allows you to specify the expected data types of variables, function arguments, and return values. It was introduced 
+in Python 3.5 via PEP 484 and has since become a standard practice to improve code readability and facilitate static analysis tools.
+
+**Benefits of Type Hinting**
+
+1. Improved Readability: Type hints make it clear what type of data is expected, making the code easier to understand for others and your future self.
+2. Error Detection: Static analysis tools like MyPy can use type hints to detect type errors before runtime, reducing bugs and improving code quality.
+3.Better Tooling Support: Modern IDEs and editors can leverage type hints to provide better autocompletion, refactoring, and error checking features.
+4. Documentation: Type hints serve as a form of documentation, indicating the intended usage of functions and classes.
+
+**Syntax of Type Hinting** <br>
+Type hints can be added to variables, function arguments, and return values using annotations.
+
+1. Variable Annotations:
+
+```bash
+age: int = 25
+name: str = "Alice"
+is_student: bool = True
+```
+
+2. Function Annotations:
+
+```bash
+def greet(name: str) -> str:
+    return f"Hello, {name}!"
+```
+
+3. Multiple Arguments and Return Types:
+
+```bash
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+4. Optional Types: Use the Optional type from the typing module for values that could be None.
+
+```bash
+from typing import Optional
+
+def get_user_name(user_id: int) -> Optional[str]:
+    # Function logic here
+    return None  # Example return value
+```
+
+5. Union Types: Use the Union type when a variable can be of multiple types.
+
+```bash
+from typing import Union
+
+def get_value(key: str) -> Union[int, str]:
+    # Function logic here
+    return "value"  # Example return value
+```
+
+6. List and Dictionary Types: Use the List and Dict types from the typing module for collections.
+
+```bash
+from typing import List, Dict
+
+def process_data(data: List[int]) -> Dict[str, int]:
+    # Function logic here
+    return {"sum": sum(data)}  # Example return value
+```
+
+7. Type Aliases: Create type aliases for complex types to make the code more readable.
+
+```bash
+from typing import List, Tuple
+
+Coordinates = List[Tuple[int, int]]
+
+def draw_shape(points: Coordinates) -> None:
+    # Function logic here
+    pass
+```
+
+**Example of Type Hinting in a Class** <br>
+Here is a more comprehensive example using type hints in a class:
+
+```bash
+from typing import List
+
+class Student:
+    def __init__(self, name: str, age: int, grades: List[int]) -> None:
+        self.name = name
+        self.age = age
+        self.grades = grades
+
+    def average_grade(self) -> float:
+        return sum(self.grades) / len(self.grades)
+
+    def add_grade(self, grade: int) -> None:
+        self.grades.append(grade)
+
+# Example usage
+student = Student("Alice", 20, [90, 85, 88])
+print(student.average_grade())  # Output: 87.66666666666667
+student.add_grade(92)
+print(student.average_grade())  # Output: 88.75
+```
+
+### Conclusion
+Type hinting in Python enhances code readability, facilitates error detection through static analysis, and improves tooling support. By adopting 
+type hinting, you can write clearer and more maintainable code, reducing the likelihood of bugs and making your codebase easier to navigate for yourself and others.

From 23a7577e92f4d1d618ef6784feec46a4294640f2 Mon Sep 17 00:00:00 2001
From: Pradnya Gaitonde <116059908+PradnyaGaitonde@users.noreply.github.com>
Date: Wed, 5 Jun 2024 00:35:53 +0530
Subject: [PATCH 56/76] Update index.md

Updated index for Type hinting content
---
 contrib/advanced-python/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index 5ea5081..e2179e7 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -1,3 +1,4 @@
 # List of sections
 
 - [Decorators/\*args/**kwargs](decorator-kwargs-args.md)
+- [Type Hinting/\*args/**kwargs](Type_Hinting.md)

From a3961ff390a95c24b33bca10b047f89ec63a7201 Mon Sep 17 00:00:00 2001
From: Pradnya Gaitonde <116059908+PradnyaGaitonde@users.noreply.github.com>
Date: Wed, 5 Jun 2024 00:44:22 +0530
Subject: [PATCH 57/76] Create Itertools_module.md

Added content for itertools module in python.
---
 contrib/advanced-python/Itertools_module.md | 144 ++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 contrib/advanced-python/Itertools_module.md

diff --git a/contrib/advanced-python/Itertools_module.md b/contrib/advanced-python/Itertools_module.md
new file mode 100644
index 0000000..501a127
--- /dev/null
+++ b/contrib/advanced-python/Itertools_module.md
@@ -0,0 +1,144 @@
+# The 'itertools' Module in Python
+The itertools module in Python provides a collection of fast, memory-efficient tools that are useful for creating and working with iterators. These functions 
+allow you to iterate over data in various ways, often combining, filtering, or extending iterators to generate complex sequences efficiently.
+
+## Benefits of itertools
+1. Efficiency: Functions in itertools are designed to be memory-efficient, often generating elements on the fly and avoiding the need to store large intermediate results.
+2. Conciseness: Using itertools can lead to more readable and concise code, reducing the need for complex loops and temporary variables.
+3. Composability: Functions from itertools can be easily combined, allowing you to build complex iterator pipelines from simple building blocks.
+
+## Useful Functions in itertools <br>
+Here are some of the most useful functions in the itertools module, along with examples of how to use them:
+
+1. 'count': Generates an infinite sequence of numbers, starting from a specified value.
+
+```bash
+import itertools
+
+counter = itertools.count(start=10, step=2)
+for _ in range(5):
+    print(next(counter))
+# Output: 10, 12, 14, 16, 18
+```
+
+2. 'cycle': Cycles through an iterable indefinitely.
+
+```bash
+import itertools
+
+cycler = itertools.cycle(['A', 'B', 'C'])
+for _ in range(6):
+    print(next(cycler))
+# Output: A, B, C, A, B, C
+```
+
+3.'repeat': Repeats an object a specified number of times or indefinitely.
+
+```bash
+import itertools
+
+repeater = itertools.repeat('Hello', 3)
+for item in repeater:
+    print(item)
+# Output: Hello, Hello, Hello
+```
+
+4. 'chain': Combines multiple iterables into a single iterable.
+
+```bash
+import itertools
+
+combined = itertools.chain([1, 2, 3], ['a', 'b', 'c'])
+for item in combined:
+    print(item)
+# Output: 1, 2, 3, a, b, c
+```
+
+5. 'islice': Slices an iterator, similar to slicing a list.
+
+```bash
+import itertools
+
+sliced = itertools.islice(range(10), 2, 8, 2)
+for item in sliced:
+    print(item)
+# Output: 2, 4, 6
+```
+
+6. 'compress': Filters elements in an iterable based on a corresponding selector iterable.
+
+```bash
+import itertools
+
+data = ['A', 'B', 'C', 'D']
+selectors = [1, 0, 1, 0]
+result = itertools.compress(data, selectors)
+for item in result:
+    print(item)
+# Output: A, C
+```
+
+7. 'permutations': Generates all possible permutations of an iterable.
+
+```bash
+import itertools
+
+perms = itertools.permutations('ABC', 2)
+for item in perms:
+    print(item)
+# Output: ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')
+```
+
+8. 'combinations': Generates all possible combinations of a specified length from an iterable.
+
+```bash
+import itertools
+
+combs = itertools.combinations('ABC', 2)
+for item in combs:
+    print(item)
+# Output: ('A', 'B'), ('A', 'C'), ('B', 'C')
+```
+
+9. 'product': Computes the Cartesian product of input iterables.
+
+```bash
+import itertools
+
+prod = itertools.product('AB', '12')
+for item in prod:
+    print(item)
+# Output: ('A', '1'), ('A', '2'), ('B', '1'), ('B', '2')
+```
+
+10. 'groupby': Groups elements of an iterable by a specified key function.
+
+```bash
+import itertools
+
+data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 25}, {'name': 'Charlie', 'age': 30}]
+sorted_data = sorted(data, key=lambda x: x['age'])
+grouped = itertools.groupby(sorted_data, key=lambda x: x['age'])
+for key, group in grouped:
+    print(key, list(group))
+# Output: 
+# 25 [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 25}]
+# 30 [{'name': 'Charlie', 'age': 30}]
+```
+
+11. 'accumulate': Makes an iterator that returns accumulated sums, or accumulated results of other binary functions specified via the optional func argument.
+
+```bash
+import itertools
+import operator
+
+data = [1, 2, 3, 4, 5]
+acc = itertools.accumulate(data, operator.mul)
+for item in acc:
+    print(item)
+# Output: 1, 2, 6, 24, 120
+```
+
+## Conclusion
+The itertools module is a powerful toolkit for working with iterators in Python. Its functions enable efficient and concise handling of iterable data, allowing you to create complex data processing pipelines with minimal memory overhead. 
+By leveraging itertools, you can improve the readability and performance of your code, making it a valuable addition to your Python programming arsenal.

From 294afa2d325da4ce3afff3bf193a286f72832be0 Mon Sep 17 00:00:00 2001
From: Pradnya Gaitonde <116059908+PradnyaGaitonde@users.noreply.github.com>
Date: Wed, 5 Jun 2024 00:46:53 +0530
Subject: [PATCH 58/76] Update index.md

Updated index for itertools module content.
---
 contrib/advanced-python/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index 5ea5081..f8a366f 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -1,3 +1,4 @@
 # List of sections
 
 - [Decorators/\*args/**kwargs](decorator-kwargs-args.md)
+- ['itertools' module](Itertools_module.md)

From 7a83f1524a4c4e5a1c6b27401d98b53fcc5492c4 Mon Sep 17 00:00:00 2001
From: Pradnya Gaitonde <116059908+PradnyaGaitonde@users.noreply.github.com>
Date: Wed, 5 Jun 2024 00:48:20 +0530
Subject: [PATCH 59/76] Update index.md

---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index e2179e7..36bd103 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -1,4 +1,4 @@
 # List of sections
 
 - [Decorators/\*args/**kwargs](decorator-kwargs-args.md)
-- [Type Hinting/\*args/**kwargs](Type_Hinting.md)
+- [Type Hinting](Type_Hinting.md)

From 77b313abe8c4357496d4e9f3ccfb6ec0a027deb0 Mon Sep 17 00:00:00 2001
From: Arihant Yadav <147732947+arihunter-18@users.noreply.github.com>
Date: Wed, 5 Jun 2024 02:39:44 +0530
Subject: [PATCH 60/76] Update closures.md

---
 contrib/advanced-python/closures.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/closures.md b/contrib/advanced-python/closures.md
index 87ad058..e363c15 100644
--- a/contrib/advanced-python/closures.md
+++ b/contrib/advanced-python/closures.md
@@ -98,4 +98,4 @@ The **i**=*i* argument in the closure function is used to capture the current va
 For more examples related to closures, [click here](https://dev.to/bshadmehr/understanding-closures-in-python-a-comprehensive-tutorial-11ld).
 
 ## Summary
-Closures in Python provide a powerful mechanism for encapsulating state and behavior, enabling more flexible and modular code. Understanding and effectively using closures enables the creation of function factories, allows functions to have state, and facilitates functional programming techniques.
\ No newline at end of file
+Closures in Python provide a powerful mechanism for encapsulating state and behavior, enabling more flexible and modular code. Understanding and effectively using closures enables the creation of function factories, allows functions to have state, and facilitates functional programming techniques

From bccf4eacf8e1364ac1a4229f08c7c9d8d0327f1f Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Thu, 6 Jun 2024 05:55:26 +0530
Subject: [PATCH 61/76] Update hierarchical-clustering.md

---
 .../hierarchical-clustering.md                | 20 -------------------
 1 file changed, 20 deletions(-)

diff --git a/contrib/machine-learning/hierarchical-clustering.md b/contrib/machine-learning/hierarchical-clustering.md
index 3f9e606..9382270 100644
--- a/contrib/machine-learning/hierarchical-clustering.md
+++ b/contrib/machine-learning/hierarchical-clustering.md
@@ -2,20 +2,6 @@
 
 Hierarchical Clustering is a method of cluster analysis that seeks to build a hierarchy of clusters. This README provides an overview of the hierarchical clustering algorithm, including its fundamental concepts, types, steps, and how to implement it using Python.
 
-## Table of Contents
-
-1. [Introduction](#introduction)
-2. [Concepts](#concepts)
-3. [Types of Hierarchical Clustering](#types-of-hierarchical-clustering)
-4. [Steps in Hierarchical Clustering](#steps-in-hierarchical-clustering)
-5. [Linkage Criteria](#linkage-criteria)
-6. [Implementation](#implementation)
-    - [Using Scikit-learn](#using-scikit-learn)
-    - [Code Example](#code-example)
-7. [Evaluation Metrics](#evaluation-metrics)
-8. [Conclusion](#conclusion)
-9. [References](#references)
-
 ## Introduction
 
 Hierarchical Clustering is an unsupervised learning method used to group similar objects into clusters. Unlike other clustering techniques, hierarchical clustering does not require the number of clusters to be specified beforehand. It produces a tree-like structure called a dendrogram, which displays the arrangement of the clusters and their sub-clusters.
@@ -111,9 +97,3 @@ print(data.head())
 ## Conclusion
 
 Hierarchical clustering is a versatile and intuitive method for clustering data. It is particularly useful when the number of clusters is not known beforehand. By understanding the different linkage criteria and evaluation metrics, one can effectively apply hierarchical clustering to various types of data.
-
-## References
-
-- [Scikit-learn Documentation](https://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering)
-- [Wikipedia: Hierarchical Clustering](https://en.wikipedia.org/wiki/Hierarchical_clustering)
-- [Towards Data Science: Hierarchical Clustering Explained](https://towardsdatascience.com/hierarchical-clustering-explained-925d9e1600c1)

From c6c8ffe1f694f2795c468afac8655059146a2d1c Mon Sep 17 00:00:00 2001
From: Ankit Mahato <ankmahato@gmail.com>
Date: Thu, 6 Jun 2024 06:01:22 +0530
Subject: [PATCH 62/76] Update transformers.md

---
 contrib/machine-learning/transformers.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 0dcf697..7d4fa38 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -6,10 +6,12 @@ mechanism. Before transformers, predecessors of attention mechanism were added t
 Transformers are a revolutionary approach to natural language processing (NLP). Unlike older models, they excel at understanding long-range connections between words. This "attention" mechanism lets them grasp the context of a sentence, making them powerful for tasks like machine translation, text summarization, and question answering. Introduced in 2017, transformers are now the backbone of many large language models, including tools you might use every day. Their ability to handle complex relationships in language is fueling advancements in AI across various fields.
 
 ## Model Architecture
-<p align="center">
-    <img src="assets/transformer-architecture.png" alt="Model Architecture" /><br>
-Source: <a href="https://arxiv.org/pdf/1706.03762">Attention Is All You Need</a> - Figure 1
-</p>
+
+![Model Architecture](assets/transformer-architecture.png)
+
+
+Source: [Attention Is All You Need](https://arxiv.org/pdf/1706.03762)
+
 
 ### Encoder
 The encoder is composed of a stack of identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, positionwise fully connected feed-forward network. Each encoder consists of two major components: a self-attention mechanism and a feed-forward neural network. The self-attention mechanism accepts input encodings from the previous encoder and weights their relevance to each other to generate output encodings. The feed-forward neural network further processes each output encoding individually. These output encodings are then passed to the next encoder as its input, as well as to the decoders.

From 3d52c978c52da5c0120cb73b4be8ee77d9810613 Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Thu, 6 Jun 2024 13:56:27 +0530
Subject: [PATCH 63/76] Update transformers.md

Replaced html with latex equation outside the blockquotes
---
 contrib/machine-learning/transformers.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 7d4fa38..95ccada 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -9,7 +9,6 @@ Transformers are a revolutionary approach to natural language processing (NLP).
 
 ![Model Architecture](assets/transformer-architecture.png)
 
-
 Source: [Attention Is All You Need](https://arxiv.org/pdf/1706.03762)
 
 
@@ -21,12 +20,12 @@ The decoder is also composed of a stack of identical layers. In addition to the
 
 ### Attention
 #### Scaled Dot-Product Attention
-The input consists of queries and keys of dimension dk, and values of dimension dv. We compute the dot products of the query with all keys, divide each by √d<sub>k</sub>, and apply a softmax function to obtain the weights on the values.
+The input consists of queries and keys of dimension $d_k$ , and values of dimension $d_v$. We compute the dot products of the query with all keys, divide each by $\sqrt d_k$ , and apply a softmax function to obtain the weights on the values.
 
 > Attention(Q, K, V) = softmax(QK<sup>T</sup> / √d<sub>k</sub>) * V
 
 #### Multi-Head Attention
-Instead of performing a single attention function with d<sub>model</sub>-dimensional keys, values and queries, it is beneficial to linearly project the queries, keys and values h times with different, learned linear projections to d<sub>k</sub>, d<sub>k</sub> and d<sub>v</sub> dimensions, respectively. 
+Instead of performing a single attention function with $d_{model}$-dimensional keys, values and queries, it is beneficial to linearly project the queries, keys and values h times with different, learned linear projections to $d_k$ , $d_k$ and $d_v$ dimensions, respectively. 
 
 Multi-head attention allows the model to jointly attend to information from different representation
 subspaces at different positions. With a single attention head, averaging inhibits this.
@@ -41,7 +40,7 @@ where the projections are parameter matrices.
 
 #### Masked Attention
 It may be necessary to cut out attention links between some word-pairs. For example, the decoder for token position 
-𝑡 should not have access to token position 𝑡+1.
+$t$ should not have access to token position $t+1$.
 
 > MaskedAttention(Q, K, V) = softmax(M + (QK<sup>T</sup> / √d<sub>k</sub>)) * V
 

From b230028124bcc03f56ed8f87ebeb437a38bce21c Mon Sep 17 00:00:00 2001
From: SAM <60264918+SAM-DEV007@users.noreply.github.com>
Date: Thu, 6 Jun 2024 14:17:40 +0530
Subject: [PATCH 64/76] Update transformers.md

Mathematical equations are converted to LaTex mathematical equations.
---
 contrib/machine-learning/transformers.md | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/contrib/machine-learning/transformers.md b/contrib/machine-learning/transformers.md
index 95ccada..5a27688 100644
--- a/contrib/machine-learning/transformers.md
+++ b/contrib/machine-learning/transformers.md
@@ -20,9 +20,9 @@ The decoder is also composed of a stack of identical layers. In addition to the
 
 ### Attention
 #### Scaled Dot-Product Attention
-The input consists of queries and keys of dimension $d_k$ , and values of dimension $d_v$. We compute the dot products of the query with all keys, divide each by $\sqrt d_k$ , and apply a softmax function to obtain the weights on the values.
+The input consists of queries and keys of dimension $d_k$ , and values of dimension $d_v$. We compute the dot products of the query with all keys, divide each by $\sqrt {d_k}$ , and apply a softmax function to obtain the weights on the values.
 
-> Attention(Q, K, V) = softmax(QK<sup>T</sup> / √d<sub>k</sub>) * V
+$$Attention(Q, K, V) = softmax(\dfrac{QK^T}{\sqrt{d_k}}) \times V$$
 
 #### Multi-Head Attention
 Instead of performing a single attention function with $d_{model}$-dimensional keys, values and queries, it is beneficial to linearly project the queries, keys and values h times with different, learned linear projections to $d_k$ , $d_k$ and $d_v$ dimensions, respectively. 
@@ -30,11 +30,11 @@ Instead of performing a single attention function with $d_{model}$-dimensional k
 Multi-head attention allows the model to jointly attend to information from different representation
 subspaces at different positions. With a single attention head, averaging inhibits this.
 
-> MultiHead(Q, K, V) = Concat(head<sub>1</sub>, <sub>...</sub>, head<sub>h</sub>) * W<sup>O</sup>
+$$MultiHead(Q, K, V) = Concat(head_1, _{...}, head_h) \times W^O$$
 
 where,
 
-> head<sub>i</sub> = Attention(Q * W<sub>i</sub><sup>Q</sup>, K * W<sub>i</sub><sup>K</sup>, V * W<sub>i</sub><sup>V</sup>)
+$$head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)$$
 
 where the projections are parameter matrices.
 
@@ -42,20 +42,22 @@ where the projections are parameter matrices.
 It may be necessary to cut out attention links between some word-pairs. For example, the decoder for token position 
 $t$ should not have access to token position $t+1$.
 
-> MaskedAttention(Q, K, V) = softmax(M + (QK<sup>T</sup> / √d<sub>k</sub>)) * V
+$$MaskedAttention(Q, K, V) = softmax(M + \dfrac{QK^T}{\sqrt{d_k}}) \times V$$
 
 ### Feed-Forward Network
 Each of the layers in the encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically. This
 consists of two linear transformations with a ReLU activation in between.
-> FFN(x) = (max(0, (x * W1) + b1) * W2) + b2
+
+$$FFN(x) = max(0, xW_1 + b_1)W_2 + b_2$$
 
 ### Positional Encoding
 A positional encoding is a fixed-size vector representation that encapsulates the relative positions of tokens within a target sequence: it provides the transformer model with information about where the words are in the input sequence.
 
 The sine and cosine functions of different frequencies:
-> PE<sub>(pos,2i)</sub> = sin(pos/10000<sup>2i/dmodel</sup>)
 
-> PE<sub>(pos,2i+1)</sub> = cos(pos/10000<sup>2i/dmodel</sup>)
+$$PE<sub>(pos,2i)</sub> = \sin({\dfrac{pos}{10000^{\dfrac{2i}{d_{model}}}}})$$
+
+$$PE<sub>(pos,2i)</sub> = \cos({\dfrac{pos}{10000^{\dfrac{2i}{d_{model}}}}})$$
 
 ## Implementation
 ### Theory

From 76e07d587bc12188361ed05a65dae893792f2bfa Mon Sep 17 00:00:00 2001
From: Kosuri Indu <kosurilindu@gmail.com>
Date: Thu, 6 Jun 2024 23:53:19 +0530
Subject: [PATCH 65/76] Added in index.md

---
 contrib/ds-algorithms/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/ds-algorithms/index.md b/contrib/ds-algorithms/index.md
index 1d7293b..d39c33f 100644
--- a/contrib/ds-algorithms/index.md
+++ b/contrib/ds-algorithms/index.md
@@ -13,3 +13,4 @@
 - [Stacks in Python](stacks.md)
 - [Sliding Window Technique](sliding-window.md)
 - [Trie](trie.md)
+- [Hashing through Chaining](hashing-chaining.md)

From 35c8620187ea011e49025d414c0e82fa33d31f62 Mon Sep 17 00:00:00 2001
From: Kosuri Indu <kosurilindu@gmail.com>
Date: Thu, 6 Jun 2024 23:56:03 +0530
Subject: [PATCH 66/76] Added in index.md

---
 contrib/ds-algorithms/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/ds-algorithms/index.md b/contrib/ds-algorithms/index.md
index 1d7293b..30881ac 100644
--- a/contrib/ds-algorithms/index.md
+++ b/contrib/ds-algorithms/index.md
@@ -13,3 +13,4 @@
 - [Stacks in Python](stacks.md)
 - [Sliding Window Technique](sliding-window.md)
 - [Trie](trie.md)
+- [Hashing through Linear Probing](hashing-linear-probing.md)

From 8bafaaa091b06d8cbcd49b607633276ea70d3b01 Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 10:20:05 +0530
Subject: [PATCH 67/76] Rename K-nearest neighbor (KNN).md to knn.md

---
 .../machine-learning/{K-nearest neighbor (KNN).md => knn.md}    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename contrib/machine-learning/{K-nearest neighbor (KNN).md => knn.md} (99%)

diff --git a/contrib/machine-learning/K-nearest neighbor (KNN).md b/contrib/machine-learning/knn.md
similarity index 99%
rename from contrib/machine-learning/K-nearest neighbor (KNN).md
rename to contrib/machine-learning/knn.md
index 748f808..85578f3 100644
--- a/contrib/machine-learning/K-nearest neighbor (KNN).md	
+++ b/contrib/machine-learning/knn.md
@@ -119,4 +119,4 @@ plt.show()
 - **Feature Scaling:** Since KNN relies on distance calculations, features should be scaled (standardized or normalized) to ensure that all features contribute equally to the distance computation.
 - **Distance Metrics:** The choice of distance metric (Euclidean, Manhattan, etc.) can affect the performance of the algorithm.
 
-In conclusion, KNN is a versatile and easy-to-implement algorithm suitable for various classification and regression tasks, particularly when working with small datasets and well-defined features. However, careful consideration should be given to the choice of K, feature scaling, and distance metrics to optimize its performance.
\ No newline at end of file
+In conclusion, KNN is a versatile and easy-to-implement algorithm suitable for various classification and regression tasks, particularly when working with small datasets and well-defined features. However, careful consideration should be given to the choice of K, feature scaling, and distance metrics to optimize its performance.

From 906333954390d915e4c85b92e6ccc95919a878d8 Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 10:20:27 +0530
Subject: [PATCH 68/76] Update index.md

---
 contrib/machine-learning/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index e5f5371..deafdda 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -16,4 +16,4 @@
 - [Types_of_Cost_Functions](cost-functions.md)
 - [Clustering](clustering.md)
 - [Grid Search](grid-search.md)
-- [K-nearest neighbor (KNN)](K-nearest neighbor (KNN).md)
\ No newline at end of file
+- [K-nearest neighbor (KNN)](knn.md)

From c7adf3b7c6154849e621124963a7810edcd0c6c0 Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 10:28:51 +0530
Subject: [PATCH 69/76] Rename ensemble_learning.md to ensemble-learning.md

---
 .../{ensemble_learning.md => ensemble-learning.md}              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename contrib/machine-learning/{ensemble_learning.md => ensemble-learning.md} (98%)

diff --git a/contrib/machine-learning/ensemble_learning.md b/contrib/machine-learning/ensemble-learning.md
similarity index 98%
rename from contrib/machine-learning/ensemble_learning.md
rename to contrib/machine-learning/ensemble-learning.md
index 940bd09..508f45e 100644
--- a/contrib/machine-learning/ensemble_learning.md
+++ b/contrib/machine-learning/ensemble-learning.md
@@ -137,4 +137,4 @@ print("Classification Report:\n", classification_report(y_test, y_pred))
 ```
 
 ## Conclusion
-Ensemble Learning is a powerful technique that combines multiple models to improve overall performance. By leveraging the strengths of different models, it provides better accuracy, robustness, and generalization. However, it comes with increased complexity and computational cost. Understanding and implementing ensemble methods can significantly enhance machine learning solutions.
\ No newline at end of file
+Ensemble Learning is a powerful technique that combines multiple models to improve overall performance. By leveraging the strengths of different models, it provides better accuracy, robustness, and generalization. However, it comes with increased complexity and computational cost. Understanding and implementing ensemble methods can significantly enhance machine learning solutions.

From 26b6691bf4de1f29fcf7475f1368a4571a0226ac Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 10:29:21 +0530
Subject: [PATCH 70/76] Update index.md

---
 contrib/machine-learning/index.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/contrib/machine-learning/index.md b/contrib/machine-learning/index.md
index e64c95d..8e2d84e 100644
--- a/contrib/machine-learning/index.md
+++ b/contrib/machine-learning/index.md
@@ -11,8 +11,7 @@
 - [TensorFlow.md](tensorFlow.md)
 - [PyTorch.md](pytorch.md)
 - [Types of optimizers](Types_of_optimizers.md)
-- [Random Forest](Random_Forest.md)
-- [Ensemble Learning](ensemble_learning.md)
+- [Ensemble Learning](ensemble-learning.md)
 - [Logistic Regression](logistic-regression.md)
 - [Clustering](clustering.md)
 - [Grid Search](grid-search.md)

From f637a28ba1c2326adedeea7fdf633f48e2199e2f Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 11:00:46 +0530
Subject: [PATCH 71/76] Update index.md

---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index 631423a..f61fdf0 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -10,4 +10,4 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
-- [List Comprehension](list_comprehension.md)
+- [List Comprehension](list-comprehension.md)

From c2740251604764cb12945841c828dc0033fbb151 Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 11:01:08 +0530
Subject: [PATCH 72/76] Rename list_comprehension.md to list-comprehension.md

---
 .../{list_comprehension.md => list-comprehension.md}              | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/advanced-python/{list_comprehension.md => list-comprehension.md} (100%)

diff --git a/contrib/advanced-python/list_comprehension.md b/contrib/advanced-python/list-comprehension.md
similarity index 100%
rename from contrib/advanced-python/list_comprehension.md
rename to contrib/advanced-python/list-comprehension.md

From 98ad137d915cdb5039045aa0ee7f0c696c02ade5 Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 11:34:42 +0530
Subject: [PATCH 73/76] Rename Type_Hinting.md to type-hinting.md

---
 contrib/advanced-python/{Type_Hinting.md => type-hinting.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/advanced-python/{Type_Hinting.md => type-hinting.md} (100%)

diff --git a/contrib/advanced-python/Type_Hinting.md b/contrib/advanced-python/type-hinting.md
similarity index 100%
rename from contrib/advanced-python/Type_Hinting.md
rename to contrib/advanced-python/type-hinting.md

From 3e346a29a6bcddd25fe0c7af7b8b2dbffe74a3da Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 11:37:03 +0530
Subject: [PATCH 74/76] Rename Itertools_module.md to itertools.md

---
 contrib/advanced-python/{Itertools_module.md => itertools.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename contrib/advanced-python/{Itertools_module.md => itertools.md} (100%)

diff --git a/contrib/advanced-python/Itertools_module.md b/contrib/advanced-python/itertools.md
similarity index 100%
rename from contrib/advanced-python/Itertools_module.md
rename to contrib/advanced-python/itertools.md

From 4f096eb6a64c5e798f04a68740c7a8aae39b048c Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 23:39:18 +0530
Subject: [PATCH 75/76] Update index.md

---
 contrib/advanced-python/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/advanced-python/index.md b/contrib/advanced-python/index.md
index 59ea9b5..b093e44 100644
--- a/contrib/advanced-python/index.md
+++ b/contrib/advanced-python/index.md
@@ -12,7 +12,7 @@
 - [Protocols](protocols.md)
 - [Exception Handling in Python](exception-handling.md)
 - [Generators](generators.md)
-- [Match Case Statement](match_case_statement.md)
+- [Match Case Statement](match-case.md)
 - [Closures](closures.md)
 - [Filter](filter-function.md)
 - [Reduce](reduce-function.md)

From 7d18fe39d45bfdd2e4d432c8bc70b4c7496f7e2d Mon Sep 17 00:00:00 2001
From: Ashita Prasad <ashitaprasad92@gmail.com>
Date: Sat, 8 Jun 2024 23:39:52 +0530
Subject: [PATCH 76/76] Update and rename match_case_statement.md to
 match-case.md

---
 .../advanced-python/{match_case_statement.md => match-case.md}   | 1 -
 1 file changed, 1 deletion(-)
 rename contrib/advanced-python/{match_case_statement.md => match-case.md} (95%)

diff --git a/contrib/advanced-python/match_case_statement.md b/contrib/advanced-python/match-case.md
similarity index 95%
rename from contrib/advanced-python/match_case_statement.md
rename to contrib/advanced-python/match-case.md
index b617f7a..1b4f017 100644
--- a/contrib/advanced-python/match_case_statement.md
+++ b/contrib/advanced-python/match-case.md
@@ -247,6 +247,5 @@ The match case statements provide an elegant and readible format to perform oper
 ## Further Reading
 This article provides a brief introduction to the match case statements and the overview on the pattern matching operations. To know more, the below articles can be used for in-depth understanding of the topic.
 
-- [Python Match Case Statement - GeeksForGeeks](https://www.geeksforgeeks.org/python-match-case-statement/)
 - [PEP 634 – Structural Pattern Matching: Specification](https://peps.python.org/pep-0634/)
 - [PEP 636 – Structural Pattern Matching: Tutorial](https://peps.python.org/pep-0636/)