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

* Regression is a supervised machine learning technique which is used to predict continuous values.

* Regression is a statistical method used to model the relationship between a dependent variable (often denoted as 'y') and one or more independent variables (often denoted as 'x'). The goal of regression analysis is to understand how the dependent variable changes as the independent variables change.

1. Linear Regression

2. Polynomial Regression

3. Stepwise Regression

4. Decision Tree Regression

5. Random Forest Regression

6. Ridge Regression

7. Lasso Regression

8. ElasticNet Regression

9. Bayesian Linear Regression

10. Support Vector Regression

But, we'll first start with Linear Regression

* Linear regression is a fundamental statistical method used to model the relationship between a dependent variable (often denoted as

𝑌) and one or more independent variables (often denoted as

𝑋). The relationship is assumed to be linear, meaning that changes in the independent variables are associated with changes in the dependent variable in a straight-line fashion.

The basic form of linear regression for a single independent variable is:

**𝑌=𝛽0+𝛽1𝑋+𝜖**

Where:

* Y is the dependent variable.

* X is the independent variable.

* 𝛽0 is the intercept, representing the value of Y when X is zero

* 𝛽1 is the slope coefficient, representing the change in Y for a one-unit change in X

* ϵ is the error term, representing the variability in Y that is not explained by the linear relationship with X.

* This line imports the numpy library, which is widely used for numerical operations in Python. We use np as an alias for numpy, making it easier to reference functions and objects from the library.

* This line imports the LinearRegression class from the linear_model module of the scikit-learn library.scikit-learn is a powerful library for machine learning tasks in Python, and LinearRegression is a class provided by it for linear regression.

* This line creates a NumPy array X containing the independent variable values. In this example, we have a simple one-dimensional array representing the independent variable. The reshape(-1, 1) method reshapes the array into a column vector, necessary for use with scikit-learn

* This line creates a NumPy array Y containing the corresponding dependent variable values. These are the observed values of the dependent variable corresponding to the independent variable values in X.

* This line creates an instance of the LinearRegression class, which represents the linear regression model. We'll use this object to train the model and make predictions.

* This line fits the linear regression model to the data. The fit() method takes two arguments: the independent variable (X) and the dependent variable (Y). This method estimates the coefficients of the linear regression equation that best fit the given data.

* These lines print out the intercept (beta_0) and coefficient (beta_1) of the linear regression model. model.intercept_ gives the intercept value, and model.coef_ gives an array of coefficients, where model.coef_[0] corresponds to the coefficient of the first independent variable (in this case, there's only one).

* These lines demonstrate how to use the trained model to make predictions for new data.

* We create a new NumPy array new_data containing the values of the independent variable for which we want to predict the dependent variable values.

* We then use the predict() method of the model to obtain the predictions for these new data points. Finally, we print out the predicted values.

* To assess the linearity assumption, we can visually inspect a scatter plot of the observed values versus the predicted values.

* If the relationship between them appears linear, it suggests that the linearity assumption is reasonable.

* Homoscedasticity refers to the constant variance of the residuals across all levels of the independent variable(s). We can visually inspect a plot of residuals versus predicted values to check for homoscedasticity.

* To assess the normality of residuals, we can visually inspect a histogram or a Q-Q plot of the residuals.

* MAE measures the average magnitude of the errors in a set of predictions, without considering their direction. It is the average of the absolute differences between predicted and actual values.

* MSE measures the average of the squares of the errors. It gives more weight to larger errors, making it sensitive to outliers.

* RMSE is the square root of the MSE. It provides an error metric that is in the same units as the dependent variable, making it more interpretable.

* R-squared measures the proportion of the variance in the dependent variable that is predictable from the independent variables. It ranges from 0 to 1, where 1 indicates a perfect fit.

- [Regression in Machine Learning](Regression.md)