Получение временных меток файлов в Python: методы и особенности

import os
import datetime

file_path = "example.txt"

# Получение временных меток
creation_timestamp = os.path.getctime(file_path)
modification_timestamp = os.path.getmtime(file_path)

# Конвертация Unix timestamp в читаемый формат
creation_date = datetime.datetime.fromtimestamp(creation_timestamp)
modification_date = datetime.datetime.fromtimestamp(modification_timestamp)

print(f"Файл создан: {creation_date}")
print(f"Последняя модификация: {modification_date}")

import os
import datetime

file_path = "example.txt"

try:
# Получение и форматирование временных меток
creation_time = datetime.datetime.fromtimestamp(
os.path.getctime(file_path)
).strftime("%Y-%m-%d %H:%M:%S")

modification_time = datetime.datetime.fromtimestamp(
os.path.getmtime(file_path)
).strftime("%Y-%m-%d %H:%M:%S")

print(f"Создан: {creation_time}")
print(f"Изменён: {modification_time}")

except FileNotFoundError:
print(f"Файл {file_path} не найден")
except PermissionError:
print(f"Недостаточно прав для доступа к {file_path}")

import os
import datetime

file_path = "example.txt"
stats = os.stat(file_path)

# На Windows ctime — время создания, на Unix — время изменения inode
ctime = datetime.datetime.fromtimestamp(stats.st_ctime)
# Время последнего изменения содержимого
mtime = datetime.datetime.fromtimestamp(stats.st_mtime)
# Время последнего доступа
atime = datetime.datetime.fromtimestamp(stats.st_atime)

print(f"st_ctime: {ctime}")
print(f"st_mtime: {mtime}")
print(f"st_atime: {atime}")

from pathlib import Path
import datetime

file_path = Path("example.txt")

# Проверяем, существует ли файл
if file_path.exists():
# Получаем статистику файла
stats = file_path.stat()

# Преобразуем временные метки в читаемый формат
ctime = datetime.datetime.fromtimestamp(stats.st_ctime)
mtime = datetime.datetime.fromtimestamp(stats.st_mtime)

print(f"Время создания/изменения атрибутов: {ctime}")
print(f"Время последней модификации: {mtime}")
else:
print(f"Файл {file_path} не существует")

from pathlib import Path
import datetime

# Путь к директории
directory = Path("./data")

# Перебираем все файлы .txt в директории
for file_path in directory.glob("*.txt"):
stats = file_path.stat()

# Форматируем вывод временных меток
modified = datetime.datetime.fromtimestamp(stats.st_mtime).strftime("%Y-%m-%d %H:%M")

# Выводим имя файла и время модификации
print(f"{file_path.name}: последнее изменение {modified}")

from pathlib import Path

# Путь к директории
directory = Path("./documents")

# Получаем список файлов, отсортированных по времени модификации
sorted_files = sorted(
directory.glob("*.pdf"), 
key=lambda path: path.stat().st_mtime,
reverse=True # Сначала новейшие файлы
)

# Выводим топ-5 самых новых файлов
print("Самые недавно измененные файлы:")
for idx, file_path in enumerate(sorted_files[:5], 1):
print(f"{idx}. {file_path.name}")

import os
import platform
import datetime
from pathlib import Path

def get_file_dates(file_path):
"""Получает даты создания и модификации файла с учетом особенностей платформы"""
file_path = Path(file_path)

if not file_path.exists():
return None, None

stats = file_path.stat()

# Время модификации одинаково интерпретируется на всех платформах
modification_time = datetime.datetime.fromtimestamp(stats.st_mtime)

# Время создания зависит от платформы
if platform.system() == "Windows":
# На Windows st_ctime это действительно время создания
creation_time = datetime.datetime.fromtimestamp(stats.st_ctime)
else:
# На Unix-системах true "creation time" обычно недоступен
# Можно использовать минимальное из mtime и ctime как приближение
creation_time = datetime.datetime.fromtimestamp(
min(stats.st_ctime, stats.st_mtime)
)

return creation_time, modification_time

# Использование функции
file_path = "example.txt"
creation, modification = get_file_dates(file_path)

if creation and modification:
print(f"Файл предположительно создан: {creation}")
print(f"Последнее изменение: {modification}")
else:
print(f"Файл {file_path} не существует")

from pathlib import Path
import datetime
import shutil
import os

def archive_old_files(source_dir, archive_dir, days_threshold=30):
"""Перемещает файлы старше указанного порога в архивную директорию"""
source_path = Path(source_dir)
archive_path = Path(archive_dir)

# Создаем архивную директорию, если она не существует
archive_path.mkdir(exist_ok=True)

# Текущее время для сравнения
current_time = datetime.datetime.now()
threshold = datetime.timedelta(days=days_threshold)

# Счетчики для отчета
moved_count = 0
error_count = 0

for file_path in source_path.iterdir():
if not file_path.is_file():
continue

try:
# Получаем время последней модификации
mtime = datetime.datetime.fromtimestamp(file_path.stat().st_mtime)

# Проверяем, старше ли файл порогового значения
if (current_time – mtime) > threshold:
# Путь назначения в архивной директории
dest_path = archive_path / file_path.name

# Перемещаем файл
shutil.move(str(file_path), str(dest_path))
moved_count += 1
print(f"Архивирован: {file_path.name} (возраст: {(current_time – mtime).days} дней)")

except (PermissionError, OSError) as e:
print(f"Ошибка при обработке {file_path.name}: {e}")
error_count += 1

print(f"\nИтого: архивировано {moved_count} файлов, ошибок: {error_count}")

# Пример использования
archive_old_files("./documents", "./archives/old_docs", days_threshold=90)

from pathlib import Path
import datetime
import shutil
import os
from PIL import Image
from PIL.ExifTags import TAGS

def organize_photos(photos_dir):
"""Сортирует фотографии по годам и месяцам на основе EXIF или даты файла"""
photos_path = Path(photos_dir)

for photo_path in photos_path.glob("*.jpg"):
try:
# Попытка получить дату из EXIF
date_taken = get_date_from_exif(photo_path)

# Если EXIF недоступен, используем дату модификации файла
if not date_taken:
mtime = datetime.datetime.fromtimestamp(photo_path.stat().st_mtime)
date_taken = mtime

# Создаем структуру директорий YYYY/MM
year_dir = photos_path / str(date_taken.year)
month_dir = year_dir / f"{date_taken.month:02d}"

# Создаем директории, если они не существуют
month_dir.mkdir(parents=True, exist_ok=True)

# Перемещаем фотографию
shutil.move(str(photo_path), str(month_dir / photo_path.name))
print(f"Перемещено: {photo_path.name} → {date_taken.year}/{date_taken.month:02d}/")

except Exception as e:
print(f"Ошибка при обработке {photo_path.name}: {e}")

def get_date_from_exif(image_path):
"""Извлекает дату создания из EXIF метаданных изображения"""
try:
with Image.open(image_path) as img:
exif_data = img._getexif()
if not exif_data:
return None

# Ищем теги даты в EXIF
for tag_id, value in exif_data.items():
tag = TAGS.get(tag_id, tag_id)
if tag == "DateTimeOriginal":
# Формат даты в EXIF: 'YYYY:MM:DD HH:MM:SS'
return datetime.datetime.strptime(value, '%Y:%m:%d %H:%M:%S')

return None
except Exception:
return None

# Пример использования
organize_photos("./photos")

from pathlib import Path
import datetime
import time
import json
import os

def monitor_directory(directory_path, interval=60, log_file="changes_log.json"):
"""Отслеживает изменения файлов в указанной директории"""
directory = Path(directory_path)
log_path = Path(log_file)

# Загружаем предыдущее состояние, если оно существует
previous_state = {}
if log_path.exists():
try:
with open(log_path, "r") as f:
previous_state = json.load(f)
except json.JSONDecodeError:
print(f"Ошибка чтения лог-файла {log_path}. Создаем новый.")

print(f"Начинаем мониторинг директории: {directory}")
print(f"Интервал проверки: {interval} секунд")
print("Нажмите Ctrl+C для завершения...")

try:
while True:
current_state = {}
changes = {
"new_files": [],
"modified_files": [],
"deleted_files": []
}

# Сканируем текущее состояние директории
for file_path in directory.glob("**/*"):
if file_path.is_file():
rel_path = str(file_path.relative_to(directory))
stat = file_path.stat()
current_state[rel_path] = {
"mtime": stat.st_mtime,
"size": stat.st_size
}

# Проверяем, есть ли файл в предыдущем состоянии
if rel_path not in previous_state:
changes["new_files"].append(rel_path)
elif (previous_state[rel_path]["mtime"] != stat.st_mtime or
previous_state[rel_path]["size"] != stat.st_size):
changes["modified_files"].append(rel_path)

# Находим удаленные файлы
for old_file in previous_state:
if old_file not in current_state:
changes["deleted_files"].append(old_file)

# Выводим изменения
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
has_changes = any(changes.values())

if has_changes:
print(f"\n--- Изменения обнаружены ({timestamp}) ---")
if changes["new_files"]:
print(f"Новые файлы ({len(changes['new_files'])}):")
for file in changes["new_files"][:5]: # Показываем только первые 5
print(f" + {file}")
if len(changes["new_files"]) > 5:
print(f" ... и еще {len(changes['new_files']) – 5}")

if changes["modified_files"]:
print(f"Измененные файлы ({len(changes['modified_files'])}):")
for file in changes["modified_files"][:5]:
print(f" ~ {file}")
if len(changes["modified_files"]) > 5:
print(f" ... и еще {len(changes['modified_files']) – 5}")

if changes["deleted_files"]:
print(f"Удаленные файлы ({len(changes['deleted_files'])}):")
for file in changes["deleted_files"][:5]:
print(f" – {file}")
if len(changes["deleted_files"]) > 5:
print(f" ... и еще {len(changes['deleted_files']) – 5}")

# Сохраняем лог изменений
with open(log_path, "w") as f:
json.dump(current_state, f, indent=2)

# Обновляем предыдущее состояние
previous_state = current_state

# Ожидаем до следующей проверки
time.sleep(interval)

except KeyboardInterrupt:
print("\nМониторинг остановлен.")

# Пример использования
# monitor_directory("./project", interval=30)

from pathlib import Path
import datetime
import collections

def analyze_git_repo_activity(repo_path):
"""Анализирует активность разработки по временным меткам файлов"""
repo_dir = Path(repo_path)

# Проверяем, что это git-репозиторий
if not (repo_dir / ".git").exists():
print(f"Ошибка: {repo_dir} не является Git-репозиторием")
return

# Счетчики и коллекции для анализа
extensions = collections.Counter()
recent_files = []

# Сканируем все файлы, исключая .git директорию
for file_path in repo_dir.glob("**/*"):
if file_path.is_file() and ".git" not in str(file_path):
try:
# Получаем статистику файла
stat = file_path.stat()
mtime = datetime.datetime.fromtimestamp(stat.st_mtime)

# Относительный путь для лучшей читаемости
rel_path = file_path.relative_to(repo_dir)

# Подсчитываем расширения файлов
extension = file_path.suffix.lower() or "no_extension"
extensions[extension] += 1

# Добавляем файл в список недавно измененных
recent_files.append((rel_path, mtime, stat.st_size))

except (PermissionError, OSError):
continue

# Сортируем файлы по времени изменения (сначала новейшие)
recent_files.sort(key=lambda x: x[1], reverse=True)

# Выводим статистику
print(f"Анализ репозитория: {repo_dir}")
print("\nРаспределение типов файлов:")
for ext, count in extensions.most_common(10):
print(f" {ext}: {count} файлов")

print("\nНедавно измененные файлы:")
now = datetime.datetime.now()
for path, mtime, size in recent_files[:10]:
age = now – mtime
print(f" {path} – {mtime.strftime('%Y-%m-%d %H:%M')} ({age.days} дней назад)")

print("\nАнализ активности по времени:")
# Группируем файлы по дате модификации
activity_by_date = collections.defaultdict(int)
for _, mtime, _ in recent_files:
date_key = mtime.strftime('%Y-%m-%d')
activity_by_date[date_key] += 1

# Выводим топ-5 дней с наибольшей активностью
print("Дни с наибольшим числом изменений:")
for date, count in sorted(activity_by_date.items(), key=lambda x: x[1], reverse=True)[:5]:
print(f" {date}: {count} файлов изменено")

# Пример использования
# analyze_git_repo_activity("./my_project")