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

Основы синтаксиса и переменные

Программирование часто кажется магией, доступной только избранным. На самом деле, написание кода — это просто способ общения с компьютером. Вы даете ему четкие, пошаговые инструкции, а он их беспрекословно выполняет. Для автоматизации повседневных задач не нужно знать сложные математические концепции или устройство процессора. Достаточно освоить базовые правила языка и научиться формулировать свои мысли так, чтобы машина вас поняла.

Язык Python стал стандартом для автоматизации рутины именно благодаря своей простоте. Его код читается почти как обычный текст на английском языке. В этом материале мы разберем фундамент: как писать команды, как сохранять данные и как заставить скрипт работать с текстом и числами.

Базовый синтаксис: как выглядит код

Любой скрипт — это обычный текстовый файл с расширением .py, внутри которого написаны команды. Когда вы запускаете этот файл, специальная программа (интерпретатор) читает его сверху вниз, строку за строкой, и выполняет написанное.

Функция вывода

Самая первая и важная команда, с которой начинается изучение любого языка — это вывод информации на экран. В Python за это отвечает встроенная функция print().

print("Начинаю сортировку файлов...")
print(100)

Эта команда позволяет скрипту «общаться» с вами. Когда вы напишете программу для переименования сотен фотографий, именно с помощью print() скрипт сможет сообщить вам: «Обработано 50 файлов из 100» или «Работа успешно завершена».

Комментарии

Вторая важнейшая часть синтаксиса — комментарии. Это заметки в коде, которые предназначены только для человека. Компьютер полностью их игнорирует. В Python однострочный комментарий начинается с символа решетки #.

# Этот скрипт удаляет старые логи из папки
print("Очистка начата") # Выводим сообщение для пользователя

Комментарии — это ваше послание самому себе в будущее. Когда вы откроете свой скрипт через полгода, чтобы что-то в нем изменить, именно комментарии помогут быстро вспомнить, за что отвечает каждая строка.

Отступы

Во многих языках программирования для группировки команд используются фигурные скобки. Python пошел другим путем: он использует отступы (пробелы в начале строки). Это делает код визуально чистым и заставляет программистов писать аккуратно.

Обычно для одного уровня отступа используются 4 пробела. Если вы поставите пробел там, где он не нужен, программа выдаст ошибку. Пока мы будем писать команды друг под другом без отступов, но как только перейдем к условиям и циклам, отступы станут критически важными.

Переменные: коробки для хранения данных

В процессе работы скрипту нужно постоянно запоминать какую-то информацию: путь к папке, количество скачанных файлов, текущую дату или имя пользователя. Для этого используются переменные.

Переменная — это именованная область памяти компьютера. Проще всего представить ее как картонную коробку, на которую вы наклеили стикер с названием, а внутрь положили какое-то значение.

Чтобы создать переменную, нужно придумать ей имя, поставить знак равенства = (оператор присваивания) и указать значение.

folder_path = "C:/Downloads"
files_count = 15

Теперь, если вы напишете print(files_count), на экране появится число 15. Значение переменной можно менять в любой момент работы программы — отсюда и название «переменная».

Правила именования переменных

Чтобы код работал корректно и легко читался, придумывать имена для «коробок» нужно по определенным правилам:

1. Имя может состоять только из латинских букв, цифр и знака подчеркивания _.
2. Имя не может начинаться с цифры (например, 1_folder вызовет ошибку, а folder_1 — сработает).
3. В Python принято использовать стиль snake_case (змеиный регистр): слова пишутся с маленькой буквы и разделяются подчеркиванием. Например: backup_folder_path, max_retries, user_age.

Называйте переменные так, чтобы было понятно, что внутри. Имя x = 10 ни о чем не говорит. Имя days_to_delete = 10 сразу объясняет суть.

Базовые типы данных

Компьютер должен понимать, с чем именно он работает. Одно дело — сложить два числа, и совсем другое — объединить два куска текста. В Python есть несколько основных типов данных, которые покрывают 99% повседневных задач.

1. Строки (str)

Строка (string) — это любой текст. Чтобы интерпретатор понял, что перед ним текст, а не команда, строку обязательно нужно брать в кавычки (одинарные или двойные — не имеет значения).

file_name = "report.csv"
error_message = 'Файл не найден'

Строки можно складывать друг с другом. Этот процесс называется конкатенацией.

folder = "C:/Work/"
file = "data.txt"
full_path = folder + file
print(full_path) # Выведет: C:/Work/data.txt

2. Целые числа (int)

Целое число (integer) — это числа без дробной части. Они используются для подсчета количества объектов, номеров строк, дней и так далее. Пишутся без кавычек.

processed_files = 42
days_in_month = 30

С числами можно выполнять любые математические операции: сложение $a + b$, вычитание $a - b$, умножение $a * b$ и деление $a / b$.

3. Вещественные числа (float)

Вещественное число (float) — это число с дробной частью. Важно: для отделения дробной части используется точка, а не запятая.

file_size_mb = 14.5
temperature = -5.2

4. Логический тип (bool)

Логический тип (boolean) может принимать только одно из двух значений: True (Истина) или False (Ложь). Обязательно пишутся с большой буквы и без кавычек. Они работают как переключатели (флаги) и незаменимы, когда скрипт должен принять решение.

is_download_complete = True
is_error_occurred = False

Тип данных	Обозначение	Пример значения	Зачем нужен в автоматизации
Строка	str	"backup.zip"	Хранение путей к файлам, имен, URL-адресов
Целое число	int	150	Подсчет количества обработанных документов
Вещественное число	float	2.5	Расчет размера файлов в мегабайтах, задержки времени
Логический тип	bool	True	Проверка, существует ли нужная папка на диске

Преобразование типов и F-строки

Частая ошибка новичков — попытка сложить строку и число.

files_count = 5
print("Обработано файлов: " + files_count)

Этот код выдаст ошибку TypeError. Компьютер не понимает, как математически прибавить цифру к тексту. Чтобы это исправить, нужно временно превратить число в строку с помощью функции str().

files_count = 5
print("Обработано файлов: " + str(files_count))

Однако в современном Python есть гораздо более удобный и элегантный инструмент — F-строки (f-strings). Они позволяют встраивать переменные прямо внутрь текста.

Чтобы создать f-строку, нужно поставить английскую букву f перед кавычками, а переменные поместить в фигурные скобки {}.

folder = "Images"
count = 120
size = 45.5

# Использование f-строки
message = f"В папке {folder} находится {count} файлов общим объемом {size} МБ."
print(message)

Это невероятно полезно при автоматизации. Например, вам нужно каждый день создавать папку с текущей датой. Вы просто создаете переменную с датой и подставляете ее в f-строку: f"C:/Backups/backup_{current_date}".

Практический пример: расчет стоимости хранения

Давайте объединим все изученное и напишем простой скрипт. Представьте, что вы арендуете облачное хранилище. Базовый тариф включает 50 ГБ, а за каждый дополнительный гигабайт вы платите 2 доллара. Нам нужно рассчитать итоговую стоимость и вывести красивый отчет.

# 1. Задаем исходные данные (переменные)
base_storage_gb = 50
current_storage_gb = 85
price_per_extra_gb = 2.0

# 2. Выполняем расчеты
# Находим, сколько гигабайт превышает лимит
extra_gb = current_storage_gb - base_storage_gb

# Считаем доплату
additional_cost = extra_gb * price_per_extra_gb

# 3. Формируем и выводим отчет с помощью f-строки
report = f"Использовано: {current_storage_gb} ГБ. Перерасход составил {extra_gb} ГБ. К доплате: {additional_cost} USD."
print(report)

Если вы запустите этот код, интерпретатор подставит все значения, выполнит математику (вычтет 50 из 85, получит 35, затем умножит 35 на 2.0) и выведет готовый текст: «Использовано: 85 ГБ. Перерасход составил 35 ГБ. К доплате: 70.0 USD.».

Вы только что написали свою первую программу, которая берет сырые данные, обрабатывает их по заданному алгоритму и выдает полезный результат. Понимание того, как сохранять данные в переменные и как правильно указывать их типы — это фундамент, на котором строятся абсолютно все скрипты, от простых переименователей файлов до сложных ботов.

Условия и циклы

Скрипты, которые выполняют команды строго сверху вниз, полезны, но их возможности ограничены. Настоящая автоматизация начинается тогда, когда программа умеет принимать решения и повторять рутинные действия без вашего участия. Представьте, что вы разбираете почту: вы не просто перекладываете все письма в одну стопку, а смотрите на адресата. Счета отправляются в одну папку, личные письма — в другую, а спам летит в корзину.

Чтобы научить компьютер такой же логике, в программировании используются условные операторы и циклы. Это два главных инструмента, которые превращают глупый калькулятор в умного виртуального помощника.

Условные операторы: как скрипт принимает решения

Условный оператор — это конструкция, которая позволяет выполнять определенный кусок кода только в том случае, если выполняется заданное правило. В Python для этого используется ключевое слово if (если).

Синтаксис выглядит как обычное предложение на английском языке. После слова if пишется само условие, затем ставится двоеточие. Со следующей строки с обязательным отступом (обычно 4 пробела) пишутся команды, которые нужно выполнить.

file_size_mb = 150

if file_size_mb > 100:
    print("Файл слишком большой!")
    print("Начинаю сжатие...")

В этом примере интерпретатор проверяет: правда ли, что значение переменной больше 100? Если да (результат $150 > 100$ — это True), то команды с отступом выполнятся. Если бы размер файла был равен 50, компьютер просто проигнорировал бы этот блок кода и пошел дальше.

Операторы сравнения

Чтобы формулировать условия, используются математические знаки сравнения. Большинство из них вам знакомы со школы, но есть одно критически важное отличие.

Знак в коде	Что означает	Пример использования
>	Больше	$x > 10$
<	Меньше	$y < 50$
>=	Больше или равно	$age \geq 18$
<=	Меньше или равно	$price \leq 1000$
==	Равно (проверка)	$status == "error"$
!=	Не равно	$extension \neq ".pdf"$

Самая частая ошибка новичков — путаница между = и ==. Одиночное равно = — это команда «положить значение в коробку» (присваивание). Двойное равно == — это вопрос к компьютеру: «Равны ли эти два значения?». Если вы напишете if a = 5:, программа выдаст ошибку.

Альтернативные пути: else и elif

Часто нам нужно не просто выполнить действие при совпадении условия, но и предусмотреть запасной план. Для этого используется слово else (иначе).

password = "qwerty"

if password == "secret123":
    print("Доступ разрешен. Открываю архив.")
else:
    print("Неверный пароль. Доступ закрыт.")

Если вариантов развития событий больше двух, на помощь приходит elif (сокращение от else if — «иначе если»). Вы можете добавлять сколько угодно проверок elif между if и else.

Представьте, что вы пишете скрипт для сортировки загрузок. Вам нужно раскидать файлы по папкам в зависимости от их формата.

file_extension = ".mp4"

if file_extension == ".pdf":
    print("Перемещаю в папку 'Документы'")
elif file_extension == ".mp3":
    print("Перемещаю в папку 'Музыка'")
elif file_extension == ".mp4":
    print("Перемещаю в папку 'Видео'")
else:
    print("Оставляю в папке 'Разное'")

Компьютер будет проверять условия сверху вниз. Как только он найдет совпадение (в нашем случае это третья проверка), он выполнит нужную команду и пропустит все остальные варианты.

Логические связки: and, or, not

Иногда для принятия решения нужно учесть сразу несколько факторов. Например, вы хотите удалить файл, только если он старый и занимает много места. Для объединения условий используются логические операторы.

• and (И) — требует, чтобы оба условия были правдивыми.
• or (ИЛИ) — сработает, если хотя бы одно условие правдиво.
• not (НЕ) — переворачивает результат (правду делает ложью, а ложь — правдой).

days_old = 45
size_mb = 600

# Файл удалится, только если он старше 30 дней И весит больше 500 МБ
if days_old > 30 and size_mb > 500:
    print("Файл подходит под критерии очистки. Удаляю...")

Циклы: автоматизация рутины

Условия делают скрипт умным, а циклы делают его неутомимым. Цикл — это конструкция, которая заставляет компьютер повторять один и тот же блок кода несколько раз. В Python есть два основных вида циклов: while и for.

Цикл while (пока)

Цикл while работает по принципу: «Делай это, пока условие остается истинным». Он идеально подходит для ситуаций, когда вы заранее не знаете, сколько раз придется повторить действие.

Представьте, что вы качаете большой файл, и скрипт должен дождаться окончания загрузки, прежде чем начать с ним работать.

downloaded_mb = 0
total_mb = 100

while downloaded_mb < total_mb:
    print(f"Скачано {downloaded_mb} из {total_mb} МБ...")
    # Имитируем скачивание 25 МБ за один шаг
    downloaded_mb = downloaded_mb + 25

print("Загрузка завершена! Начинаю обработку.")

При запуске этого кода программа проверит: $0 < 100$? Да. Выведет текст, прибавит 25. Затем снова проверит: $25 < 100$? Да. И так до тех пор, пока переменная downloaded_mb не станет равна 100. Как только условие $100 < 100$ станет ложным (False), цикл остановится.

Важно: При работе с while всегда следите за тем, чтобы условие когда-нибудь стало ложным. Если вы забудете добавить строку downloaded_mb = downloaded_mb + 25, переменная навсегда останется нулем, и скрипт будет печатать сообщение бесконечно. Это называется «бесконечный цикл».

Цикл for (для каждого)

Если while ждет выполнения условия, то цикл for берет готовый набор элементов и проходит по каждому из них по очереди. Это самый частый инструмент в автоматизации: применить действие для каждого файла в папке, для каждой строки в таблице, для каждого письма в ящике.

Чтобы понять for, нам нужно познакомиться с базовой коллекцией данных — списком (list). Список — это просто несколько значений, записанных через запятую внутри квадратных скобок [].

# Создаем список из трех имен файлов
files_to_process = ["report.xlsx", "photo.jpg", "budget.csv"]

for current_file in files_to_process:
    print(f"Обрабатываю файл: {current_file}")

Разберем синтаксис по словам:

1. for — начало цикла.
2. current_file — новая переменная, которую мы придумываем прямо здесь. В нее по очереди будут попадать значения из списка.
3. in — ключевое слово «в».
4. files_to_process — список, по которому мы идем.

Интерпретатор сам возьмет первый элемент ("report.xlsx"), положит его в current_file, выполнит print(). Затем вернется наверх, возьмет второй элемент ("photo.jpg"), и так до конца списка. Вам не нужно вручную считать элементы или останавливать цикл — Python сделает все сам.

Практический пример: умный фильтр файлов

Давайте объединим списки, цикл for и условный оператор if, чтобы написать прототип реального скрипта.

Задача: у нас есть список файлов из папки «Загрузки». Нам нужно найти среди них только изображения (файлы, заканчивающиеся на .jpg) и подсчитать их количество.

# 1. Исходные данные
downloads = ["resume.pdf", "vacation.jpg", "invoice.pdf", "cat.jpg", "notes.txt"]
images_count = 0  # Переменная-счетчик

# 2. Запускаем цикл по всем файлам
for file in downloads:
    # 3. Проверяем условие: заканчивается ли имя на .jpg?
    # Метод .endswith() проверяет окончание строки
    if file.endswith(".jpg"):
        print(f"Найдено изображение: {file}")
        # Увеличиваем счетчик на 1
        images_count = images_count + 1
    else:
        print(f"Пропускаю документ: {file}")

# 4. Выводим итоговый результат
print(f"\nГотово! Всего найдено изображений: {images_count}")

Как работает этот код: Скрипт поочередно берет каждое имя из списка downloads. Внутри цикла он натыкается на развилку if. Если имя заканчивается на .jpg, скрипт радостно сообщает об этом и добавляет единицу к счетчику images_count. Если нет — срабатывает блок else, и файл просто игнорируется. В самом конце, когда цикл завершил работу со всеми пятью элементами, программа выводит итоговое число.

Понимание того, как вкладывать условия внутрь циклов — это ключевой навык. Именно так работают программы, которые массово переименовывают фотографии, удаляют старые логи с серверов или собирают данные из сотен Excel-таблиц в один отчет.

Функции: ваши личные мини-программы

Представьте, что вы каждое утро готовите кофе. Вы берете зерна, мелете их, наливаете воду в кофеварку, нажимаете кнопку и ждете. Если вам нужно сделать три чашки для гостей, вы повторите этот процесс трижды. В программировании копировать и вставлять один и тот же код снова и снова — плохая идея. Если вы решите поменять рецепт (например, добавить корицу), вам придется искать и исправлять каждую скопированную часть кода.

Чтобы избежать этой рутины, программисты используют функции. Функция — это именованный блок кода, который выполняет одну конкретную задачу. Вы создаете ее один раз, а затем просто вызываете по имени там, где она нужна.

Как создать функцию

В Python создание функции начинается с ключевого слова def (от английского define — определить). Затем идет имя функции, круглые скобки и двоеточие. Со следующей строки с отступом пишется сам код.

# Создаем функцию
def greet_user():
    print("Доброе утро!")
    print("Проверяю новые файлы...")

# Вызываем функцию дважды
greet_user()
greet_user()

В этом примере мы «научили» компьютер новой команде greet_user(). Пока мы ее не вызовем, код внутри нее выполняться не будет.

Аргументы и результат (return)

Настоящая польза функций раскрывается, когда они могут принимать исходные данные и возвращать готовый результат. Вернемся к аналогии с кофеваркой: вода и зерна — это аргументы (то, что мы кладем внутрь), а готовый кофе — это возвращаемое значение.

Давайте напишем функцию для автоматизации работы с файлами. Часто скачанные из интернета документы имеют ужасные названия с пробелами, которые мешают при сортировке. Наша функция будет принимать грязное имя файла, заменять пробелы на нижние подчеркивания и делать все буквы строчными.

def clean_filename(old_name):
    # Заменяем пробелы на подчеркивания
    step_1 = old_name.replace(" ", "_")
    # Делаем все буквы маленькими
    step_2 = step_1.lower()

    # Возвращаем готовый результат
    return step_2

# Используем нашу функцию
file1 = "Отчет За Март.xlsx"
cleaned_file = clean_filename(file1)

print(f"Старое имя: {file1}")
print(f"Новое имя: {cleaned_file}")

Ключевое слово return — это команда «отдай результат и заверши работу». Как только функция выполняет return, она передает обработанные данные обратно в основную программу, где мы можем сохранить их в новую переменную cleaned_file.

Модули: инструменты из коробки

Вы научились писать собственные функции, но что, если нужная вам задача уже решена кем-то другим? Python славится своим подходом «батарейки в комплекте». Вместе с языком поставляется огромная библиотека готовых решений для самых разных задач: от математических вычислений до скачивания сайтов.

Эти наборы готовых функций называются модулями. Модуль — это просто отдельный файл с кодом на Python. Чтобы воспользоваться инструментами из модуля, его нужно подключить к вашему скрипту с помощью команды import.

Работа с датой и временем

Представьте, что вам нужно ежедневно создавать папку для резервных копий, и в названии папки должна быть текущая дата. Писать логику календаря с нуля — безумие. Вместо этого мы возьмем встроенный модуль datetime.

# Подключаем модуль для работы с датой
import datetime

# Просим модуль дать нам сегодняшний день
today = datetime.date.today()

print(f"Сегодняшняя дата: {today}")

# Создаем имя для папки
folder_name = f"backup_{today}"
print(f"Имя новой папки: {folder_name}")

Синтаксис datetime.date.today() читается так: «Зайди в модуль datetime, найди там раздел date и вызови функцию today()».

Взаимодействие с операционной системой

Для автоматизации рутины на компьютере вам понадобится модуль os (от Operating System). Он позволяет скрипту «видеть» файлы на вашем жестком диске, создавать папки и удалять документы.

import os

# Узнаем, в какой папке сейчас запущен скрипт
current_folder = os.getcwd()
print(f"Скрипт работает в папке: {current_folder}")

# Получаем список всех файлов в этой папке
all_files = os.listdir(current_folder)
print("Найдены файлы:")
print(all_files)

Практический пример: массовое переименование

Теперь объединим все знания из этого и предыдущих уроков (переменные, циклы, условия, функции и модули), чтобы создать мощный скрипт.

Задача: У нас есть список файлов. Нам нужно найти среди них только текстовые документы (заканчиваются на .txt), очистить их названия от пробелов с помощью нашей функции и добавить к названию сегодняшнюю дату.

import datetime

# 1. Наша функция для очистки текста
def clean_filename(old_name):
    name_without_spaces = old_name.replace(" ", "_")
    return name_without_spaces.lower()

# 2. Исходные данные (в реальности мы бы получили их через os.listdir())
files_in_folder = ["My Notes.txt", "photo.jpg", "TO DO list.txt", "budget.xlsx"]

# 3. Получаем текущую дату
today_str = str(datetime.date.today())

# 4. Запускаем цикл по всем файлам
for file in files_in_folder:
    # Проверяем условие: это текстовый файл?
    if file.endswith(".txt"):
        # Очищаем имя
        clean_name = clean_filename(file)

        # Формируем финальное имя с датой
        # Например: 2023-10-25_my_notes.txt
        final_name = f"{today_str}_{clean_name}"

        print(f"Переименовываю: '{file}' ---> '{final_name}'")
    else:
        print(f"Пропускаю файл: '{file}' (не текстовый)")

Разбив сложную задачу на маленькие шаги и используя готовые модули, мы написали скрипт, который может сэкономить часы ручного труда. Если завтра вам понадобится обрабатывать не текстовые файлы, а таблицы, вам достаточно будет изменить всего одно условие в коде.

Чтение и запись файлов: наделяем скрипты памятью

До сих пор все наши программы страдали от «амнезии». Переменные, списки и результаты работы функций существовали только в оперативной памяти компьютера. Как только скрипт завершал работу, все данные бесследно исчезали. Если мы хотели отфильтровать список файлов или посчитать расходы, нам приходилось заново вписывать исходные данные прямо в код программы.

В реальной жизни автоматизация работает иначе. Данные приходят извне: это могут быть выгрузки из бухгалтерских программ, списки email-адресов от коллег или логи ошибок. Чтобы скрипт приносил настоящую пользу, он должен уметь брать информацию из существующих документов на жестком диске, обрабатывать ее и сохранять результат в новые файлы.

Анатомия работы с файлом

Взаимодействие с файлом в Python очень похоже на то, как вы работаете с обычным бумажным блокнотом. Чтобы прочитать записи или добавить новые, вам нужно выполнить три обязательных шага:

1. Найти нужный блокнот и открыть его.
2. Прочитать текст или записать новый.
3. Закрыть блокнот и положить его на место.

Для первого шага используется встроенная функция open(). Она сообщает операционной системе, что ваша программа хочет получить доступ к определенному документу.

У функции open() есть три главных аргумента:

• Имя файла (путь к нему).
• Режим работы (что именно мы собираемся делать).
• Кодировка (правила, по которым компьютер понимает символы).

Режимы работы (mode)

Когда вы открываете файл, вы должны сразу сказать Python, каковы ваши намерения. Это защищает данные от случайного удаления. Основных режимов три:

Режим	Обозначение	Описание и поведение
Чтение	'r' (от read)	Используется по умолчанию. Позволяет только читать данные. Если файла не существует, программа выдаст ошибку.
Запись	'w' (от write)	Создает новый пустой файл для записи. Осторожно: если файл с таким именем уже существует, он будет полностью стерт и перезаписан!
Добавление	'a' (от append)	Открывает файл и добавляет новые данные в самый конец, не удаляя старый текст. Если файла нет, создает новый.

Проблема кодировки

Текст в компьютере хранится в виде чисел. Кодировка — это таблица-переводчик, которая говорит компьютеру, какое число соответствует букве «А», а какое — символу «@».

Исторически сложилось так, что операционная система Windows часто использует свои специфические кодировки. Если вы попытаетесь открыть файл с русским текстом без указания правильной кодировки, вы можете получить ошибку или увидеть непонятные символы (так называемые «кракозябры»). Чтобы этого избежать, всегда добавляйте параметр encoding='utf-8'. Это современный мировой стандарт, который поддерживает все языки мира.

Безопасное открытие: менеджер контекста

Самая частая ошибка новичков — открыть файл, сделать с ним что-то и забыть закрыть с помощью команды close(). Если файл не закрыт, он остается заблокированным в оперативной памяти. Вы не сможете удалить его или переместить, пока не перезапустите программу. А если во время записи произойдет ошибка, часть данных может не сохраниться.

Чтобы не держать в голове необходимость закрытия файлов, в Python придумали менеджер контекста — конструкцию with.

# Создаем новый файл и записываем в него текст
with open("my_notes.txt", "w", encoding="utf-8") as file:
    file.write("Это моя первая строчка в файле.\n")
    file.write("А это вторая строчка.")

print("Файл успешно создан и закрыт!")

Давайте разберем этот синтаксис:

• Ключевое слово with открывает «безопасную зону».
• open(...) открывает файл в режиме записи ("w").
• as file означает «сохрани этот открытый файл в переменную с именем file».
• Далее идет блок кода с отступом. Все, что написано с отступом, работает с открытым файлом.
• Как только отступы заканчиваются, Python автоматически закрывает файл. Даже если внутри произойдет критическая ошибка, файл будет безопасно закрыт.

Обратите внимание на символ \n в конце первой строки. Это специальный невидимый символ переноса строки. Метод write() не нажимает клавишу Enter за вас. Если вы не добавите \n, весь текст склеится в одну длинную нечитаемую колбасу.

Чтение данных из файла

Представьте, что у нас есть файл shopping_list.txt, в котором записаны продукты для покупки. Мы хотим прочитать его содержимое.

Если файл небольшой, мы можем прочитать его целиком за один раз с помощью метода read():

with open("shopping_list.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print("Содержимое файла:")
    print(content)

Метод read() берет весь текст из файла и превращает его в одну большую строку (тип данных string). Это удобно для коротких заметок. Но что, если файл весит 5 гигабайт (например, это лог-файл сервера за год)? Попытка загрузить его целиком приведет к тому, что у компьютера закончится оперативная память, и программа зависнет.

Построчное чтение

Для работы с большими объемами данных профессионалы используют построчное чтение. Файловый объект в Python работает как коллекция строк. Это значит, что мы можем использовать цикл for, с которым познакомились в предыдущих уроках, чтобы перебирать файл строчка за строчкой.

with open("shopping_list.txt", "r", encoding="utf-8") as file:
    for line in file:
        # Очищаем строку от скрытых символов переноса
        clean_line = line.strip()
        print(f"Нужно купить: {clean_line}")

В этом примере компьютер читает только одну строку за раз, обрабатывает ее и тут же забывает, переходя к следующей. Это позволяет обрабатывать файлы любого размера, не перегружая память.

Здесь мы использовали строковый метод strip(). Зачем он нужен? Когда вы нажимаете Enter в текстовом редакторе, в файл записывается тот самый невидимый символ \n. Функция print() тоже по умолчанию добавляет перенос строки. Если не использовать strip(), между нашими строками при выводе на экран появятся лишние пустые интервалы. Метод strip() аккуратно отрезает все пробелы и переносы по краям строки.

Практический пример: автоматизация обработки отчета

Теперь объединим все наши знания: переменные, условия, циклы, функции и работу с файлами.

Сценарий: Вы работаете в отделе продаж. Каждое утро система выгружает файл raw_orders.txt. В нем вперемешку записаны успешные заказы, отмененные заказы и просто пустые строки из-за сбоя системы. Ваша задача — вытащить оттуда только успешные заказы, привести их к единому виду (сделать все буквы заглавными) и сохранить в новый чистый файл approved_orders.txt.

Исходный файл raw_orders.txt выглядит так:

заказ 101 - успешен

ЗАКАЗ 102 - отменен заказ 103 - УСПЕШЕН

заказ 104 - ошибка оплаты

Напишем скрипт для автоматизации этой рутины:

# 1. Функция для проверки и очистки строки
def process_order(order_line):
    # Убираем лишние пробелы и переносы
    clean_text = order_line.strip()

    # Если после очистки строка оказалась пустой, возвращаем None
    if clean_text == "":
        return None

    # Проверяем, есть ли слово "успешен" (переводим в нижний регистр для надежности)
    if "успешен" in clean_text.lower():
        # Делаем текст заглавным и возвращаем
        return clean_text.upper()
    else:
        return None

# 2. Открываем сразу два файла: один для чтения, другой для записи
# Обратите внимание на синтаксис: файлы перечисляются через запятую
with open("raw_orders.txt", "r", encoding="utf-8") as file_in, \
     open("approved_orders.txt", "w", encoding="utf-8") as file_out:

    # Запускаем счетчик успешных заказов
    success_count = 0

    # 3. Читаем исходный файл построчно
    for line in file_in:
        # Отправляем строку в нашу функцию
        result = process_order(line)

        # Если функция вернула обработанный текст (а не None)
        if result != None:
            # Записываем его в новый файл, не забывая добавить перенос строки
            file_out.write(result + "\n")
            success_count = success_count + 1

# 4. Выводим итог на экран
print(f"Обработка завершена. Сохранено успешных заказов: {success_count}")

Что мы сделали в этом скрипте? Мы создали конвейер. Данные заходят из файла raw_orders.txt, проходят через фильтр в виде нашей функции process_order(), которая отсеивает мусор и форматирует текст. Затем очищенные данные сразу же записываются в новый файл approved_orders.txt.

Использование конструкции with для двух файлов одновременно гарантирует, что оба документа будут корректно закрыты после завершения работы цикла. Даже если в исходном файле будет миллион строк, наш скрипт обработает их за пару секунд, не зависнет и сэкономит вам часы монотонной ручной работы.

Практика автоматизации задач

Вы уже познакомились с базовыми строительными блоками Python: научились сохранять информацию в переменные, управлять потоком программы с помощью условий и циклов, а также читать и записывать данные в текстовые файлы. По отдельности эти инструменты похожи на детали конструктора. Самое время собрать из них работающие механизмы, которые возьмут на себя вашу повседневную рутину.

В реальной жизни автоматизация — это не написание сложных нейросетей. Чаще всего это простые скрипты из 10–15 строк кода, которые избавляют вас от необходимости монотонно кликать мышкой, переименовывать сотни документов или искать нужную строчку в огромном отчете.

Давайте разберем три классических сценария, с которыми сталкивается практически каждый пользователь компьютера, и напишем для них программы.

Сценарий 1: Уборка в папке «Загрузки»

Знакомая ситуация: папка Downloads (или «Загрузки») на вашем компьютере со временем превращается в цифровую свалку. Там вперемешку лежат картинки, рабочие PDF-документы, установочные файлы и архивы. Найти нужный файл становится все сложнее.

Мы напишем скрипт, который проанализирует содержимое этой папки и автоматически разложит файлы по категориям: картинки — в одну папку, документы — в другую.

Для работы с файловой системой компьютера нам понадобятся два встроенных модуля Python:

• os (от Operating System) — позволяет программе «видеть» файлы и папки, прямо как вы видите их в проводнике.
• shutil (от Shell Utilities) — работает как виртуальные руки: может копировать, перемещать и удалять файлы.

Пишем код сортировщика

import os
import shutil

# 1. Создаем переменные с путями к папкам
# Замените путь на тот, где находится ваша папка с файлами
source_folder = "C:/Users/User/Downloads"
documents_folder = "C:/Users/User/Downloads/Documents"
images_folder = "C:/Users/User/Downloads/Images"

# 2. Получаем список всех файлов в папке
all_files = os.listdir(source_folder)

# 3. Запускаем цикл для проверки каждого файла
for filename in all_files:

    # Создаем полный путь к текущему файлу
    file_path = os.path.join(source_folder, filename)

    # Проверяем, что это именно файл, а не другая папка
    if os.path.isfile(file_path):

        # Условие для картинок: если имя заканчивается на .jpg или .png
        if filename.endswith(".jpg") or filename.endswith(".png"):
            # Перемещаем файл в папку с картинками
            shutil.move(file_path, os.path.join(images_folder, filename))
            print(f"Картинка {filename} успешно перемещена!")

        # Условие для документов: если имя заканчивается на .pdf
        elif filename.endswith(".pdf"):
            # Перемещаем файл в папку с документами
            shutil.move(file_path, os.path.join(documents_folder, filename))
            print(f"Документ {filename} успешно перемещен!")

Как это работает?

В этом скрипте мы объединили все базовые концепции:

1. Переменные и строки: Мы сохранили пути к папкам в переменные source_folder, documents_folder и images_folder. Это строковый тип данных.
2. Списки: Функция os.listdir() просматривает папку и возвращает список (list), состоящий из имен всех файлов внутри.
3. Цикл for: Мы берем этот список и перебираем его элемент за элементом. Переменная filename на каждом шаге цикла принимает значение нового имени файла.
4. Условия if/elif: С помощью строкового метода .endswith() (который проверяет, заканчивается ли строка на указанный текст) мы задаем правила. Если файл заканчивается на .jpg — отправляем его к картинкам. Если на .pdf — к документам.

Обратите внимание на функцию os.path.join(). Она безопасно склеивает пути к файлам, автоматически подставляя правильные слеши (косые черты) в зависимости от того, работаете вы на Windows или Mac.

Сценарий 2: Массовое переименование файлов

Представьте, что вы фотограф или бухгалтер. У вас есть папка с сотней файлов, которые называются IMG_001.jpg, IMG_002.jpg или report_1.xlsx, report_2.xlsx. Вам нужно добавить к каждому файлу текущую дату или название проекта, чтобы получилось 2023_Project_IMG_001.jpg.

Переименовывать сто файлов вручную — это потеря получаса рабочего времени и риск опечаток. Python сделает это за доли секунды.

import os

folder_path = "C:/Users/User/Work/Reports"
prefix = "2023_Q4_"

# Получаем список файлов
files = os.listdir(folder_path)

# Перебираем файлы в цикле
for filename in files:
    # Нас интересуют только файлы Excel
    if filename.endswith(".xlsx"):

        # Формируем новое имя, просто складывая строки
        new_name = prefix + filename

        # Склеиваем полные пути
        old_file_path = os.path.join(folder_path, filename)
        new_file_path = os.path.join(folder_path, new_name)

        # Команда на переименование
        os.rename(old_file_path, new_file_path)

        print(f"Файл {filename} переименован в {new_name}")

Здесь магия происходит благодаря базовой операции со строками — конкатенации (сложению). Когда мы пишем prefix + filename, Python просто берет строку "2023_Q4_" и приклеивает к ней строку "report_1.xlsx". Затем функция os.rename() получает старый адрес файла и новый адрес, мгновенно меняя название документа на жестком диске.

Сценарий 3: Извлечение важных данных из текста

Автоматизировать можно не только работу с самими файлами, но и с их содержимым. Допустим, система безопасности вашего сайта или корпоративной программы каждый день генерирует текстовый лог-файл (server_log.txt). В нем тысячи строк: информация о входах пользователей, системные уведомления и ошибки.

Ваша задача — найти все ошибки (строки, содержащие слово "ERROR") и сохранить их в отдельный файл для отправки программистам. Читать тысячу строк глазами невозможно.

Используем знания из предыдущего урока о чтении и записи файлов:

# Открываем исходный файл для чтения ('r') и новый для записи ('w')
with open("server_log.txt", "r", encoding="utf-8") as log_file, \
     open("errors_only.txt", "w", encoding="utf-8") as error_file:

    error_count = 0

    # Читаем исходный файл построчно
    for line in log_file:

        # Условие: если слово ERROR есть в текущей строке
        if "ERROR" in line:
            # Записываем эту строку в новый файл
            error_file.write(line)
            # Увеличиваем счетчик ошибок на 1
            error_count = error_count + 1

print(f"Анализ завершен. Найдено и сохранено ошибок: {error_count}")

В этом скрипте мы используем оператор in. Это невероятно удобный инструмент Python, который проверяет, содержится ли одна строка внутри другой. Если условие "ERROR" in line оказывается истинным (True), скрипт берет эту конкретную строку и копирует ее в новый документ.

Золотые правила безопасности при автоматизации

Когда вы даете программе власть над вашими файлами, цена ошибки возрастает. Если вы случайно напишете скрипт, который удаляет файлы вместо их перемещения, восстановить данные будет сложно.

Чтобы ваши первые шаги в автоматизации были безопасными, соблюдайте три правила:

1. Тренируйтесь на кошках. Никогда не запускайте новый, только что написанный скрипт на папке с важными рабочими документами или семейными фотографиями. Создайте тестовую папку, скопируйте туда 5–10 ненужных файлов и проверяйте код на них.
2. Используйте холостой ход (print). Прежде чем использовать команды os.rename() или shutil.move(), закомментируйте их (поставьте знак # в начале строки) и напишите вместо них print(new_file_path). Так скрипт просто выведет на экран текст того, что он собирается сделать. Вы сможете проверить, правильно ли формируются новые имена и пути, не меняя реальные файлы.
3. Абсолютные пути надежнее. В примерах выше мы использовали полные пути (например, C:/Users/User/Downloads). Это называется абсолютным путем. Он гарантирует, что скрипт будет работать именно с той папкой, с которой нужно, независимо от того, откуда вы его запустили.

Автоматизация — это навык, который окупается мгновенно. Потратив 20 минут на написание скрипта сегодня, вы сэкономите часы монотонной работы в будущем. Начните с малого: найдите самую скучную задачу, которую вы делаете на компьютере каждый день, и попробуйте поручить ее Python.