Handling dates and times is an essential aspect of many programming tasks.

Python provides robust modules to work with dates and times, making it easier to perform operations like formatting, parsing, and arithmetic.

This guide provides an overview of these modules and their key functionalities.

The datetime module supplies classes for manipulating dates and times. The main classes in the datetime module are:

* date: Represents a date (year, month, day).

* time: Represents a time (hour, minute, second, microsecond).

* datetime: Combines date and time information.

* timedelta: Represents the difference between two dates or times.

* tzinfo: Provides time zone information objects.

**Key Concepts:**

* Naive vs. Aware: Naive datetime objects do not contain time zone information, while aware datetime objects do.

* Immutability: date and time objects are immutable; once created, they cannot be changed.

Example:

import datetime

now = datetime.datetime.now()

print("Current date and time:", now)

Formatting involves converting datetime objects into human-readable strings. This is achieved using the strftime method, which stands for "string format time."

You can specify various format codes to dictate how the output string should be structured.

**Common Format Codes:**

* %Y: Year with century (e.g., 2024)

* %m: Month as a zero-padded decimal number (e.g., 01)

* %d: Day of the month as a zero-padded decimal number (e.g., 15)

* %H: Hour (24-hour clock) as a zero-padded decimal number (e.g., 13)

* %M: Minute as a zero-padded decimal number (e.g., 45)

* %S: Second as a zero-padded decimal number (e.g., 30)

Example:

import datetime

now = datetime.datetime.now()

formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")

print("Formatted current date and time:", formatted_now)

Parsing is the process of converting strings representing dates and times into datetime objects. The strptime method, which stands for "string parse time,"

allows you to specify the format of the input string.

Example:

import datetime

date_string = "2024-05-15 13:45:30"

date_object = datetime.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")

print("Parsed date and time:", date_object)

The timedelta class is used to represent the difference between two datetime objects. This is useful for calculations involving durations, such as finding the

number of days between two dates or adding a certain period to a date.

Example:

import datetime

date1 = datetime.datetime(2024, 5, 15, 12, 0, 0)

date2 = datetime.datetime(2024, 5, 20, 14, 30, 0)

difference = date2 - date1

print("Difference:", difference)

print("Days:", difference.days)

print("Total seconds:", difference.total_seconds())

```bash

import datetime

import pytz

tz = pytz.timezone('Asia/Kolkata')

now = datetime.datetime.now(tz)

print("Current time in Asia/Kolkata:", now)

```bash

import datetime

today = datetime.date.today()

future_date = today + datetime.timedelta(days=10)

print("Date after 10 days:", future_date)

- [Working with Dates & Times in Python](dates_and_times.md)

- [Regular Expressions in Python](regular_expressions.md)

Regular expressions (regex) are a powerful tool for pattern matching and text manipulation.

Python's re module provides comprehensive support for regular expressions, enabling efficient text processing and validation.

A regular expression is a sequence of characters defining a search pattern. Common use cases include validating input, searching within text, and extracting

specific patterns.

Literal Characters: Match exact characters (e.g., abc matches "abc").

Metacharacters: Special characters like ., *, ?, +, ^, $, [ ], and | used to build patterns.

**Common Metacharacters:**

* .: Any character except newline.

* ^: Start of the string.

* $: End of the string.

* *: 0 or more repetitions.

* +: 1 or more repetitions.

* ?: 0 or 1 repetition.

* []: Any one character inside brackets (e.g., [a-z]).

* |: Either the pattern before or after.

**Key functions in the re module:**

* re.match(): Checks for a match at the beginning of the string.

* re.search(): Searches for a match anywhere in the string.

* re.findall(): Returns a list of all matches.

* re.sub(): Replaces matches with a specified string.

Examples:

import re

print(re.match(r'\d+', '123abc').group()) # Output: 123

print(re.search(r'\d+', 'abc123').group()) # Output: 123

print(re.findall(r'\d+', 'abc123def456')) # Output: ['123', '456']

print(re.sub(r'\d+', '#', 'abc123def456')) # Output: abc#def#

Compiling regular expressions improves performance for repeated use.

Example:

import re

pattern = re.compile(r'\d+')

print(pattern.match('123abc').group()) # Output: 123

print(pattern.search('abc123').group()) # Output: 123

print(pattern.findall('abc123def456')) # Output: ['123', '456']

Parentheses () group and capture parts of the match.

Example:

import re

match = re.match(r'(\d{3})-(\d{2})-(\d{4})', '123-45-6789')

if match:

print(match.group()) # Output: 123-45-6789

print(match.group(1)) # Output: 123

print(match.group(2)) # Output: 45

print(match.group(3)) # Output: 6789

```bash

import re

print(re.search(r'\w+@\w+\.\w+', 'Contact: support@example.com').group()) # Output: support@example.com

<details>

<summary>Click to expand</summary>

- [Introduciton](#introduction)

- [Neuron to Perceptron](#neuron-to-perceptron)

- [Key concepts](#key-concepts)

- [Layers](#layers)

- [Weights and Biases](#weights-and-biases)

- [Activation Function](#activation-functions)

- [Forward and Backward Pass](#forward-and-backward-propagation)

- [Implementation](#building-from-scratch)

</details>

This guide will walk you through a fundamental neural network implementation in Python. We'll build a `Neural Network` from scratch, allowing you to grasp the core concepts of how neural networks learn and make predictions.

| `Neuron` cells forming the humand nervous system | `Perceptron` inspired from human brain |

| :----------------------------------------------- | -------------------------------------: |

| Neurons are nerve cells that send messages all over your body to allow you to do everything from breathing to talking, eating, walking, and thinking. | The perceptron is a mathematical model of a biological neuron. Performing heavy computations to think like humans. |

| Neuron collects signals from dendrites. | The first layer is knownn as Input Layer, acting like dendritres to receive the input signal. |

| Synapses are the connections between neurons where signals are transmitted. | Weights represent synapses. |

The axon terminal releases neurotransmitters to transmit the signal to other neurons. | The output is the final result – between 1 & 0, representing classification or prediction. |

Artificial neurons are the fundamental processing units in an ANN. They receive inputs, multiply them by weights (representing the strength of connections), sum those weighted inputs, and then apply an activation function to produce an output.

Neurons in ANNs are organized into layers:

* **Input Layer:** Receives the raw data.

* **(n) Hidden Layers:** (Optional) Intermediate layers where complex transformations occur. They learn to detect patterns and features in the data.

* **Output Layer:** Produces the final result (prediction or classification).

- For each input $(x_i)$, a weight $(w_i)$ is associated with it. Weights, multiplied with input units $(w_i \cdot x_i)$, determine the influence of one neuron's output on another.

- A bias $(b_i)$ is added to help influence the end product, giving the equation as $(w_i \cdot x_i + b_i)$.

- During training, the network adjusts these weights and biases to minimize errors and improve its predictions.

- An activation function is applied to the result to introduce non-linearity in the model, allowing ANNs to learn more complex relationships from the data.

- The resulting equation: $y = f(g(x))$, determines whether the neuron will "fire" or not, i.e., if its output will be used as input for the next neuron.

- Common activation functions include the sigmoid function, tanh (hyperbolic tangent), and ReLU (Rectified Linear Unit).

- **Flow of Information:** All the above steps are part of Forward Propagation. It gives the output equation as $y = f\left(\sum_{i=1}^n w_i x_i + b_i\right)$

- **Error Correction:** Backpropagation is the algorithm used to train ANNs by calculating the gradient of error at the output layer and then propagating this error backward through the network. This allows the network to adjust its weights and biases in the direction that reduces the error.

- The chain rule of calculus is the foundational concept to compute the gradient of the error:

$

\delta_{ij}(E) = \frac{\partial E}{\partial w_{ij}} = \frac{\partial E}{\partial \hat{y}_j} \cdot \frac{\partial \hat{y}_j}{\partial \theta_j} \cdot \frac{\partial \theta_j}{\partial w_{ij}}

$

where $E$ is the error, $\hat{y}_j$ is the predicted output, $\theta_j$ is the input to the activation function of the $j^{th}$ neuron, and $w_{ij}$ is the weight from neuron $i$ to neuron $j$.

import numpy as np

import matplotlib.pyplot as plt

class SimpleNeuralNetwork:

def __init__(self, input_size, hidden_size, output_size):

self.input_size = input_size

self.hidden_size = hidden_size

self.output_size = output_size

# Initialize weights and biases

self.weights_input_hidden = np.random.randn(input_size, hidden_size)

self.bias_hidden = np.random.randn(hidden_size)

self.weights_hidden_output = np.random.randn(hidden_size, output_size)

self.bias_output = np.random.randn(output_size)

def sigmoid(self, x):

return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self, x):

return x * (1 - x)

def forward(self, X):

self.hidden_layer_input = np.dot(X, self.weights_input_hidden) + self.bias_hidden

self.hidden_layer_output = self.sigmoid(self.hidden_layer_input)

self.output_layer_input = np.dot(self.hidden_layer_output, self.weights_hidden_output) + self.bias_output

self.output = self.sigmoid(self.output_layer_input)

return self.output

def backward(self, X, y, learning_rate):

output_error = y - self.output

output_delta = output_error * self.sigmoid_derivative(self.output)

hidden_error = output_delta.dot(self.weights_hidden_output.T)

hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_layer_output)

self.weights_hidden_output += self.hidden_layer_output.T.dot(output_delta) * learning_rate

self.bias_output += np.sum(output_delta, axis=0) * learning_rate

self.weights_input_hidden += X.T.dot(hidden_delta) * learning_rate

self.bias_hidden += np.sum(hidden_delta, axis=0) * learning_rate

def train(self, X, y, epochs, learning_rate):

self.losses = []

for epoch in range(epochs):

self.forward(X)

self.backward(X, y, learning_rate)

loss = np.mean(np.square(y - self.output))

self.losses.append(loss)

if epoch % 1000 == 0:

print(f"Epoch {epoch}, Loss: {loss}")

def plot_loss(self):

plt.plot(self.losses)

plt.xlabel('Epochs')

plt.ylabel('Loss')

plt.title('Training Loss Over Epochs')

plt.show()

Let's create a dummy input and outpu dataset. Here, the first two columns will be useful, while the rest might be noise.

X = np.array([[0,0], [0,1], [1,0], [1,1]])

y = np.array([[0], [1], [1], [1]])

With our input and output data ready, we'll define a simple neural network with one hidden layer containing three neurons.

input_size = 2

hidden_layers = 1

hidden_neurons = [2]

output_size = 1

To understand how well our model is learning, let's visualize the training loss over epochs.

model = NeuralNetwork(input_size, hidden_layers, hidden_neurons, output_size)

model.train(X, y, 100)