Python-скрипты: автоматизация рутинных задач в несколько строк кода

# Мой первый Python-скрипт
print("Hello, World!")

# Скрипт для персонализированного приветствия
name = input("Введите ваше имя: ")
print(f"Привет, {name}! Добро пожаловать в мир Python-скриптов!")

python --version

# Создание виртуального окружения
python -m venv myenv

# Активация на Windows
myenv\Scripts\activate

# Активация на macOS/Linux
source myenv/bin/activate

pip install requests

# Сохранение списка библиотек
pip freeze > requirements.txt

# Установка всех библиотек из списка
pip install -r requirements.txt

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Стандартные библиотеки
import os
import sys
from datetime import datetime

# Сторонние библиотеки
import pandas as pd
import requests

# Локальные модули
from helpers import format_data

API_URL = "https://api.example.com/data"
OUTPUT_FOLDER = "processed_data"
MAX_RETRIES = 3

def fetch_data(url, params=None):
"""
Получает данные с удаленного API.

Args:
url (str): URL-адрес API
params (dict, optional): Параметры запроса

Returns:
dict: Полученные данные в формате JSON

Raises:
ConnectionError: Если не удалось подключиться к API
"""
try:
response = requests.get(url, params=params)
response.raise_for_status() # Проверка на ошибки HTTP
return response.json()
except requests.exceptions.RequestException as e:
print(f"Ошибка при получении данных: {e}")
sys.exit(1)

def main():
"""Основная функция скрипта."""
print(f"Начало выполнения: {datetime.now()}")

# Получение данных
data = fetch_data(API_URL)

# Обработка данных
processed_data = process_data(data)

# Сохранение результатов
save_results(processed_data, OUTPUT_FOLDER)

print(f"Завершение выполнения: {datetime.now()}")

if __name__ == "__main__":
main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Скрипт для анализа журнала веб-сервера.
Находит наиболее часто запрашиваемые страницы и создает отчет.
"""

# Стандартные библиотеки
import os
import re
from collections import Counter
from datetime import datetime

# Константы
LOG_FILE = "access.log"
OUTPUT_FILE = "report.txt"
TOP_REQUESTS = 10

def parse_log_file(file_path):
"""
Парсит файл журнала и извлекает URL запросов.

Args:
file_path (str): Путь к файлу журнала

Returns:
list: Список URL запросов
"""
if not os.path.exists(file_path):
print(f"Файл {file_path} не найден")
return []

urls = []
pattern = r'"GET ([^"]+) HTTP/1\.[01]"'

with open(file_path, 'r') as file:
for line in file:
match = re.search(pattern, line)
if match:
urls.append(match.group(1))

return urls

def generate_report(urls, output_file, top_n):
"""
Генерирует отчет о наиболее часто запрашиваемых URL.

Args:
urls (list): Список URL запросов
output_file (str): Путь к файлу отчета
top_n (int): Количество URL для отображения
"""
url_counts = Counter(urls)
most_common = url_counts.most_common(top_n)

with open(output_file, 'w') as file:
file.write(f"Отчет сгенерирован: {datetime.now()}\n")
file.write(f"Проанализировано {len(urls)} запросов\n\n")
file.write(f"Топ-{top_n} запрашиваемых URL:\n")

for url, count in most_common:
file.write(f"{url}: {count} запросов\n")

print(f"Отчет сохранен в {output_file}")

def main():
"""Основная функция скрипта."""
print(f"Начало анализа журнала: {datetime.now()}")

urls = parse_log_file(LOG_FILE)

if urls:
generate_report(urls, OUTPUT_FILE, TOP_REQUESTS)

print(f"Анализ завершен: {datetime.now()}")

if __name__ == "__main__":
main()

import os
import shutil
from datetime import datetime

def organize_downloads():
"""Организует папку 'Загрузки' по типам файлов."""
downloads_dir = os.path.expanduser("~/Downloads")

# Словарь категорий и соответствующих расширений
categories = {
"Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],
"Documents": [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".txt"],
"Videos": [".mp4", ".avi", ".mov", ".mkv", ".wmv"],
"Audio": [".mp3", ".wav", ".flac", ".aac"],
"Archives": [".zip", ".rar", ".7z", ".tar", ".gz"]
}

# Создаем папки для категорий, если они не существуют
for category in categories:
category_path = os.path.join(downloads_dir, category)
if not os.path.exists(category_path):
os.mkdir(category_path)

# Перебираем все файлы в папке загрузок
for filename in os.listdir(downloads_dir):
file_path = os.path.join(downloads_dir, filename)

# Пропускаем папки и скрытые файлы
if os.path.isdir(file_path) or filename.startswith('.'):
continue

# Определяем расширение файла
_, extension = os.path.splitext(filename)
extension = extension.lower()

# Перемещаем файл в соответствующую категорию
for category, extensions in categories.items():
if extension in extensions:
destination = os.path.join(downloads_dir, category, filename)
shutil.move(file_path, destination)
print(f"Перемещен {filename} в {category}")
break

if __name__ == "__main__":
organize_downloads()
print("Организация файлов завершена!")

import requests
from bs4 import BeautifulSoup
import pandas as pd
import time

def scrape_weather_data(cities):
"""
Собирает данные о погоде для списка городов.

Args:
cities (list): Список городов для сбора данных

Returns:
DataFrame: Таблица с данными о погоде
"""
base_url = "https://www.example.com/weather/"
weather_data = []

for city in cities:
# Избегаем блокировки из-за слишком частых запросов
time.sleep(1)

url = base_url + city.lower().replace(' ', '-')
response = requests.get(url)

if response.status_code != 200:
print(f"Не удалось получить данные для города {city}")
continue

soup = BeautifulSoup(response.text, 'html.parser')

try:
temperature = soup.find('div', class_='current-temp').text.strip()
condition = soup.find('div', class_='current-condition').text.strip()
humidity = soup.find('span', class_='humidity-value').text.strip()

weather_data.append({
'city': city,
'temperature': temperature,
'condition': condition,
'humidity': humidity,
'timestamp': time.strftime('%Y-%m-%d %H:%M')
})

print(f"Собраны данные для {city}: {temperature}, {condition}")

except AttributeError as e:
print(f"Ошибка при парсинге данных для {city}: {e}")

# Создаем и возвращаем DataFrame
return pd.DataFrame(weather_data)

if __name__ == "__main__":
cities_list = ["Москва", "Санкт-Петербург", "Новосибирск", "Екатеринбург", "Казань"]
df = scrape_weather_data(cities_list)

# Сохраняем результаты
df.to_csv('weather_data.csv', index=False)
print(f"Данные сохранены в weather_data.csv")

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
import os

def generate_sales_report(sales_file, output_dir):
"""
Генерирует отчет о продажах с графиками и сохраняет его в указанную директорию.

Args:
sales_file (str): Путь к файлу с данными о продажах
output_dir (str): Директория для сохранения отчета
"""
# Создаем директорию, если она не существует
if not os.path.exists(output_dir):
os.makedirs(output_dir)

# Загружаем данные
df = pd.read_csv(sales_file)

# Преобразуем столбец даты
df['date'] = pd.to_datetime(df['date'])

# Рассчитываем ключевые показатели
total_revenue = df['amount'].sum()
average_order = df['amount'].mean()
most_popular_product = df['product'].value_counts().idxmax()

# Создаем отчет в текстовом формате
report_file = os.path.join(output_dir, 'sales_report.txt')
with open(report_file, 'w') as f:
f.write(f"ОТЧЕТ О ПРОДАЖАХ\n")
f.write(f"Дата создания: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n")
f.write(f"Период: {df['date'].min().strftime('%Y-%m-%d')} – {df['date'].max().strftime('%Y-%m-%d')}\n")
f.write(f"Общая выручка: {total_revenue:.2f} руб.\n")
f.write(f"Средний чек: {average_order:.2f} руб.\n")
f.write(f"Самый популярный товар: {most_popular_product}\n\n")

# Добавляем еженедельную статистику
weekly_sales = df.resample('W-Mon', on='date')['amount'].sum().reset_index()
f.write("ЕЖЕНЕДЕЛЬНЫЕ ПРОДАЖИ:\n")
for _, row in weekly_sales.iterrows():
week_end = row['date'] + timedelta(days=6)
f.write(f"{row['date'].strftime('%Y-%m-%d')} – {week_end.strftime('%Y-%m-%d')}: {row['amount']:.2f} руб.\n")

# Создаем визуализации
plt.figure(figsize=(10, 6))
df.resample('D', on='date')['amount'].sum().plot(title='Ежедневные продажи')
plt.tight_layout()
plt.savefig(os.path.join(output_dir, 'daily_sales.png'))

plt.figure(figsize=(10, 6))
df['product'].value_counts().head(10).plot(kind='bar', title='Топ-10 продаваемых товаров')
plt.tight_layout()
plt.savefig(os.path.join(output_dir, 'top_products.png'))

print(f"Отчет сохранен в директории: {output_dir}")

if __name__ == "__main__":
generate_sales_report('sales_data.csv', 'reports')

import argparse

def parse_arguments():
"""Парсит аргументы командной строки."""
parser = argparse.ArgumentParser(description='Обработка CSV-файлов с данными о продажах')
parser.add_argument('input_file', help='Путь к входному CSV-файлу')
parser.add_argument('-o', '--output', default='output.csv', help='Путь к выходному файлу')
parser.add_argument('-d', '--delimiter', default=',', help='Разделитель в CSV')
parser.add_argument('--verbose', action='store_true', help='Подробный вывод')

return parser.parse_args()

def main():
args = parse_arguments()

if args.verbose:
print(f"Обработка файла {args.input_file}")
print(f"Результат будет сохранен в {args.output}")

# Дальнейшая логика скрипта...

if __name__ == "__main__":
main()

python process_sales.py sales_data.csv -o processed_sales.csv --verbose

import logging

def setup_logging(log_file=None, level=logging.INFO):
"""Настраивает систему логирования."""
logger = logging.getLogger()
logger.setLevel(level)

# Форматирование сообщений
formatter = logging.Formatter('%(asctime)s – %(name)s – %(levelname)s – %(message)s')

# Обработчик для вывода в консоль
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)

# Обработчик для записи в файл (если указан)
if log_file:
file_handler = logging.FileHandler(log_file)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

return logger

def process_data(data):
"""Обрабатывает данные с логированием."""
logger = logging.getLogger(__name__)

logger.info(f"Начало обработки {len(data)} записей")

try:
result = perform_calculation(data)
logger.info(f"Обработка успешно завершена")
return result
except Exception as e:
logger.error(f"Ошибка при обработке данных: {e}")
logger.exception("Подробная информация об ошибке:")
raise

def main():
logger = setup_logging(log_file='data_processing.log')
logger.info("Скрипт начал выполнение")

# Основная логика...

logger.info("Скрипт завершил выполнение")

if __name__ == "__main__":
main()

import concurrent.futures
import time
import requests

def download_url(url):
"""Скачивает содержимое URL."""
start_time = time.time()
response = requests.get(url)
end_time = time.time()

return {
'url': url,
'status': response.status_code,
'size': len(response.content),
'time': end_time – start_time
}

def main():
urls = [
'https://example.com',
'https://python.org',
'https://github.com',
'https://stackoverflow.com',
'https://news.ycombinator.com'
] * 5 # Дублируем список для большего количества задач

# Последовательное выполнение
start_time = time.time()
for url in urls:
result = download_url(url)
print(f"Последовательно: {result['url']} – {result['status']} – {result['size']} bytes")
seq_time = time.time() – start_time

# Параллельное выполнение с использованием потоков
start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
future_to_url = {executor.submit(download_url, url): url for url in urls}
for future in concurrent.futures.as_completed(future_to_url):
result = future.result()
print(f"Параллельно: {result['url']} – {result['status']} – {result['size']} bytes")
par_time = time.time() – start_time

print(f"\nВремя последовательного выполнения: {seq_time:.2f} сек")
print(f"Время параллельного выполнения: {par_time:.2f} сек")
print(f"Ускорение: {seq_time / par_time:.2f}x")

if __name__ == "__main__":
main()

my_tools/
├── __init__.py
├── file_utils/
│ ├── __init__.py
│ ├── organize.py
│ └── search.py
├── web_utils/
│ ├── __init__.py
│ ├── downloader.py
│ └── scraper.py
└── setup.py

from setuptools import setup, find_packages

setup(
name="my_tools",
version="0.1.0",
packages=find_packages(),
install_requires=[
"requests>=2.25.0",
"beautifulsoup4>=4.9.0",
],
entry_points={
'console_scripts': [
'organize-files=my_tools.file_utils.organize:main',
'web-download=my_tools.web_utils.downloader:main',
],
}
)

import cProfile
import pstats
import io

def profile_func(func):
"""Декоратор для профилирования функций."""
def wrapper(*args, **kwargs):
# Создаем профилировщик
pr = cProfile.Profile()
pr.enable()

# Выполняем функцию
result = func(*args, **kwargs)

# Останавливаем профилировщик
pr.disable()

# Выводим результаты профилирования
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
ps.print_stats(15) # Показываем топ-15 функций по времени
print(s.getvalue())

return result
return wrapper

@profile_func
def process_large_dataset(filename):
"""Обрабатывает большой набор данных."""
# Код обработки данных...

def main():
process_large_dataset('big_data.csv')

if __name__ == "__main__":
main()