Как добавить дни к дате в Python: четыре проверенных способа

from datetime import datetime, timedelta

# Получаем текущую дату
current_date = datetime.now()
print(f"Текущая дата: {current_date}")

# Добавляем 5 дней
future_date = current_date + timedelta(days=5)
print(f"Дата через 5 дней: {future_date}")

# Вы также можете указать конкретную дату
specific_date = datetime(2023, 12, 31)
new_year_plus_week = specific_date + timedelta(days=7)
print(f"Неделя после Нового года: {new_year_plus_week}")

# Комбинированное добавление временных интервалов
combined_delta = current_date + timedelta(
days=30,
hours=12,
minutes=30,
seconds=45
)
print(f"Комплексная дата в будущем: {combined_delta}")

def calculate_deadline(start_date, task_duration_days):
"""
Рассчитывает дедлайн задачи на основе даты начала и длительности

Args:
start_date: Дата начала задачи (datetime)
task_duration_days: Длительность в днях (int)

Returns:
datetime: Дата дедлайна
"""
# Предположим, что рабочая неделя – пн-пт
deadline = start_date

# Добавляем дни, пропуская выходные
days_added = 0
while days_added < task_duration_days:
deadline += timedelta(days=1)
# Если это не выходной (6 – суббота, 7 – воскресенье)
if deadline.isoweekday() < 6:
days_added += 1

return deadline

# Пример использования
project_start = datetime(2023, 11, 20) # Понедельник
task_deadline = calculate_deadline(project_start, 10)
print(f"Дедлайн задачи: {task_deadline.strftime('%d.%m.%Y')}")

pip install python-dateutil

from datetime import datetime
from dateutil.relativedelta import relativedelta

# Текущая дата
current_date = datetime.now()
print(f"Текущая дата: {current_date}")

# Добавляем 5 дней с помощью relativedelta
future_date = current_date + relativedelta(days=5)
print(f"Дата через 5 дней: {future_date}")

# Добавляем 1 месяц
next_month = current_date + relativedelta(months=1)
print(f"Дата через месяц: {next_month}")

# Добавляем 1 год, 3 месяца и 5 дней
complex_date = current_date + relativedelta(years=1, months=3, days=5)
print(f"Сложная дата: {complex_date}")

# Переход к последнему дню месяца
last_day_of_month = current_date + relativedelta(day=31)
print(f"Последний день текущего месяца: {last_day_of_month}")

# Переход к следующему вторнику
next_tuesday = current_date + relativedelta(weekday=1)
print(f"Следующий вторник: {next_tuesday}")

from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta

# Начальная дата: 31 января 2023
start_date = datetime(2023, 1, 31)

# Добавление 1 месяца с использованием timedelta (30 дней)
with_timedelta = start_date + timedelta(days=30) # Это будет 2 марта 2023

# Добавление 1 месяца с использованием relativedelta
with_relativedelta = start_date + relativedelta(months=1) # Это будет 28 февраля 2023

print(f"Исходная дата: {start_date}")
print(f"timedelta +30 дней: {with_timedelta}")
print(f"relativedelta +1 месяц: {with_relativedelta}")

from dateutil.rrule import rrule, MONTHLY, MO, WE, FR
from datetime import datetime

# Получаем все понедельники, среды и пятницы за следующие 2 месяца
start = datetime.now()
end = start + relativedelta(months=2)

# Создаем правило для нужных дней недели
weekdays = list(rrule(
MONTHLY,
byweekday=(MO, WE, FR),
dtstart=start,
until=end
))

print(f"Рабочие дни на следующие 2 месяца:")
for day in weekdays[:5]: # Выводим первые 5 дней для примера
print(f"- {day.strftime('%d.%m.%Y, %A')}")

pip install pandas

import pandas as pd
from datetime import datetime

# Создаем Series с датами
dates = pd.Series([
datetime(2023, 11, 1),
datetime(2023, 11, 15),
datetime(2023, 11, 30)
])

print("Исходные даты:")
print(dates)

# Добавляем 7 дней ко всем датам одной операцией
new_dates = dates + pd.Timedelta(days=7)

print("\nДаты после добавления 7 дней:")
print(new_dates)

import pandas as pd
import numpy as np

# Создаем DataFrame с датами за месяц
date_range = pd.date_range(start='2023-11-01', end='2023-11-30', freq='D')
df = pd.DataFrame({
'date': date_range,
'value': np.random.randint(1, 100, size=len(date_range))
})

print("Исходный DataFrame:")
print(df.head())

# Добавляем столбцы с датами в будущем
df['next_day'] = df['date'] + pd.Timedelta(days=1)
df['next_week'] = df['date'] + pd.Timedelta(days=7)
df['next_month'] = df['date'] + pd.DateOffset(months=1)

print("\nDataFrame с добавленными датами:")
print(df.head())

# Анализируем данные по дням недели
df['weekday'] = df['date'].dt.day_name()
weekday_stats = df.groupby('weekday')['value'].agg(['mean', 'min', 'max'])

print("\nСтатистика по дням недели:")
print(weekday_stats)

import pandas as pd
from pandas.tseries.offsets import BusinessDay, CustomBusinessDay
from pandas.tseries.holiday import USFederalHolidayCalendar

# Создаем дату
start_date = pd.Timestamp('2023-11-24') # Пятница
print(f"Исходная дата: {start_date}")

# Добавляем 5 бизнес-дней (пропуская выходные)
business_days = start_date + BusinessDay(5)
print(f"Через 5 бизнес-дней: {business_days}") # Должна быть пятница следующей недели

# Создаем календарь с праздниками (используем встроенный календарь США для примера)
cal = USFederalHolidayCalendar()
holidays = cal.holidays(start='2023-01-01', end='2023-12-31')

# Создаем пользовательский бизнес-день, учитывающий праздники
custom_bd = CustomBusinessDay(calendar=cal)

# Добавляем 5 бизнес-дней, учитывая праздники
business_days_with_holidays = start_date + custom_bd * 5
print(f"Через 5 бизнес-дней (с учетом праздников): {business_days_with_holidays}")

# Создаем DataFrame с миллионом дат
dates = pd.date_range(start='2000-01-01', periods=1_000_000, freq='H')
df = pd.DataFrame({'original_date': dates})

# Добавляем различные смещения для всего DataFrame одновременно
%time df['plus_day'] = df['original_date'] + pd.Timedelta(days=1)
%time df['plus_month'] = df['original_date'] + pd.DateOffset(months=1)
%time df['plus_business_week'] = df['original_date'] + BusinessDay(5)

print(f"Обработано {len(df)} дат")
print(df.head())

from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
import pandas as pd

class TaskScheduler:
def __init__(self):
self.tasks = pd.DataFrame(columns=[
'name', 'priority', 'duration_days', 'start_date', 'deadline'
])

def add_task(self, name, priority, duration_days, start_date=None):
"""
Добавляет задачу в планировщик и рассчитывает дедлайн

Args:
name (str): Название задачи
priority (int): Приоритет (1-3, где 1 – высший)
duration_days (int): Продолжительность в рабочих днях
start_date (datetime, optional): Дата начала (по умолчанию сегодня)
"""
if start_date is None:
start_date = datetime.now()

# Расчет дедлайна в зависимости от приоритета
if priority == 1: # Высокий приоритет – только рабочие дни
deadline = start_date
business_days = 0
while business_days < duration_days:
deadline += timedelta(days=1)
# Проверяем, является ли день рабочим (пн-пт)
if deadline.weekday() < 5:
business_days += 1

elif priority == 2: # Средний приоритет – календарные дни
deadline = start_date + timedelta(days=duration_days)

else: # Низкий приоритет – добавляем месяц
deadline = start_date + relativedelta(days=duration_days)
# Если дедлайн выпадает на выходной, переносим на понедельник
if deadline.weekday() >= 5: # 5=суббота, 6=воскресенье
deadline += relativedelta(weekday=0) # 0=понедельник

# Добавляем задачу в DataFrame
new_task = pd.DataFrame({
'name': [name],
'priority': [priority],
'duration_days': [duration_days],
'start_date': [start_date],
'deadline': [deadline]
})
self.tasks = pd.concat([self.tasks, new_task], ignore_index=True)

def get_upcoming_deadlines(self, days=7):
"""Возвращает задачи с дедлайнами в ближайшие N дней"""
today = datetime.now()
upcoming = today + timedelta(days=days)
return self.tasks[
(self.tasks['deadline'] >= today) & 
(self.tasks['deadline'] <= upcoming)
].sort_values('deadline')

def show_all_tasks(self):
"""Выводит все задачи с отформатированными датами"""
if self.tasks.empty:
return "Нет задач"

display_df = self.tasks.copy()
display_df['start_date'] = display_df['start_date'].dt.strftime('%d.%m.%Y')
display_df['deadline'] = display_df['deadline'].dt.strftime('%d.%m.%Y')
return display_df

# Пример использования
scheduler = TaskScheduler()
scheduler.add_task("Разработать API", 1, 5)
scheduler.add_task("Написать документацию", 2, 3)
scheduler.add_task("Обновить зависимости", 3, 2)

print("Все задачи:")
print(scheduler.show_all_tasks())

print("\nБлижайшие дедлайны:")
print(scheduler.get_upcoming_deadlines())

import pandas as pd
from datetime import datetime

def generate_payment_schedule(start_date, amount, installments, 
frequency='monthly', 
payment_day=None):
"""
Генерирует график платежей

Args:
start_date (datetime): Дата первого платежа
amount (float): Общая сумма
installments (int): Количество платежей
frequency (str): Частота платежей ('weekly', 'monthly', 'quarterly')
payment_day (int, optional): Предпочитаемый день месяца для платежа
(только для monthly/quarterly)

Returns:
DataFrame: График платежей
"""
# Определяем размер одного платежа
installment_amount = round(amount / installments, 2)

# Создаем начальный DataFrame
payments = pd.DataFrame({
'payment_number': range(1, installments + 1),
'amount': [installment_amount] * installments
})

# Устанавливаем предпочитаемый день платежа
if payment_day and frequency in ['monthly', 'quarterly']:
# Если указан конкретный день месяца, используем его
start_date = start_date.replace(day=min(payment_day, 28))

# Определяем частоту для date_range
freq_map = {
'weekly': 'W',
'monthly': 'MS', # Month Start
'quarterly': 'QS' # Quarter Start
}

# Генерируем даты платежей
payment_dates = pd.date_range(
start=start_date, 
periods=installments, 
freq=freq_map[frequency]
)

# Если нужен конкретный день месяца, корректируем даты
if payment_day and frequency in ['monthly', 'quarterly']:
# Корректируем день месяца, учитывая максимальное количество дней
payment_dates = [
date.replace(day=min(payment_day, pd.Timestamp(date.year, 
date.month, 
1).days_in_month))
for date in payment_dates
]

# Добавляем даты в DataFrame
payments['payment_date'] = payment_dates

# Добавляем накопительную сумму платежей
payments['cumulative_amount'] = payments['amount'].cumsum()

# Добавляем оставшуюся сумму
payments['remaining_amount'] = amount – payments['cumulative_amount']

return payments

# Пример использования
loan_start = datetime(2023, 12, 1)
loan_amount = 12000
loan_term = 12

# Генерируем график ежемесячных платежей с платежами 15-го числа
monthly_schedule = generate_payment_schedule(
loan_start, loan_amount, loan_term, frequency='monthly', payment_day=15
)

print("График ежемесячных платежей:")
print(monthly_schedule.to_string(index=False))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Создаем искусственный набор данных о продажах
def generate_sales_data(start_date, end_date, n_products=5):
"""Генерирует тестовые данные о продажах"""
date_range = pd.date_range(start=start_date, end=end_date, freq='D')
products = [f'Product-{i}' for i in range(1, n_products + 1)]

data = []
for date in date_range:
for product in products:
# Генерируем случайное количество продаж с тенденцией роста по времени
days_from_start = (date – pd.Timestamp(start_date)).days
trend = days_from_start / 30 # Небольшой тренд роста

# Добавляем сезонность (выше продажи в выходные)
seasonality = 1.5 if date.weekday() >= 5 else 1.0

# Случайные колебания
noise = np.random.normal(1, 0.2)

# Итоговое количество продаж
sales = int(max(0, (10 + trend) * seasonality * noise))

data.append({
'date': date,
'product': product,
'sales': sales,
'revenue': sales * np.random.uniform(10, 100)
})

return pd.DataFrame(data)

def analyze_sales_by_time_period(sales_df, period='monthly', metric='sales'):
"""
Анализирует продажи по временным периодам

Args:
sales_df (DataFrame): DataFrame с продажами
period (str): Период группировки ('daily', 'weekly', 'monthly', 'quarterly')
metric (str): Метрика для анализа ('sales', 'revenue')

Returns:
DataFrame: Агрегированные данные
"""
# Создаем копию для работы
df = sales_df.copy()

# Преобразуем столбец date в datetime, если нужно
if not pd.api.types.is_datetime64_any_dtype(df['date']):
df['date'] = pd.to_datetime(df['date'])

# Определяем частоту группировки
if period == 'daily':
df['period'] = df['date']
elif period == 'weekly':
df['period'] = df['date'] – pd.to_timedelta(df['date'].dt.dayofweek, unit='d')
elif period == 'monthly':
df['period'] = df['date'].dt.to_period('M').dt.to_timestamp()
elif period == 'quarterly':
df['period'] = df['date'].dt.to_period('Q').dt.to_timestamp()
else:
raise ValueError("Поддерживаемые периоды: 'daily', 'weekly', 'monthly', 'quarterly'")

# Группируем данные
grouped = df.groupby(['period', 'product'])[metric].sum().reset_index()

# Создаем сводную таблицу для удобного представления
pivot = grouped.pivot(index='period', columns='product', values=metric)

# Добавляем общую сумму
pivot['Total'] = pivot.sum(axis=1)

# Добавляем процентное изменение по сравнению с предыдущим периодом
pivot['Change_%'] = pivot['Total'].pct_change() * 100

return pivot

# Пример использования
start_date = '2023-01-01'
end_date = '2023-06-30'

# Генерируем тестовые данные
sales_data = generate_sales_data(start_date, end_date)

# Анализируем по разным периодам
monthly_analysis = analyze_sales_by_time_period(sales_data, period='monthly', metric='revenue')
weekly_analysis = analyze_sales_by_time_period(sales_data, period='weekly', metric='sales')

print("Ежемесячный анализ выручки:")
print(monthly_analysis.round(2))

print("\nЕженедельный анализ продаж:")
print(weekly_analysis.head().round(2))

# Визуализация результатов
plt.figure(figsize=(12, 6))
monthly_analysis['Total'].plot(marker='o', linestyle='-', label='Общая выручка')
plt.title('Динамика выручки по месяцам')
plt.xlabel('Месяц')
plt.ylabel('Выручка')
plt.grid(True)
plt.tight_layout()
plt.show()