Как использовать Git: руководство для начинающих

Сегодня разбираем материал realpython.com о теме «Как использовать Git: руководство для начинающих». Практический разбор с шагами и примерами, который можно быстро применить в своей работе.

---

Редактирование файлов и ошибки — это понятная причина для использования системы контроля версий. Git фиксирует изменения, позволяя вам видеть, что было изменено и почему. Без Git даже небольшие проекты быстро превращаются в хаос, когда названия файлов типа main_final_v2_FIXED.py начинают путаться.

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

Предварительные требования

Перед тем как приступить к работе с Git, убедитесь в наличии необходимых инструментов. Это руководство подразумевает, что вы обладаете базовыми навыками работы с командной строкой и знакомы с Python.

Вот что понадобится для старта:

• Терминал или командная строка
• Python 3.10 или выше, установленный на вашей системе

Git и GitHub — не одно и то же, и разобраться в этом стоит с самого начала:

• Git — программное обеспечение для контроля версий, которое работает на вашем компьютере. Оно отслеживает изменения в файлах и управляет историей проекта локально.
• GitHub — онлайн-платформа для хостинга репозиториев Git. Она предоставляет инструменты для совместной работы, которые упрощают обмен кодом, работу в командах и резервное копирование проектов.

Для прохождения этого руководства учётная запись на GitHub не требуется. Позже, если решите поделиться кодом или сделать резервную копию онлайн, сможете отправить репозиторий на такие платформы, как GitHub, GitLab или Bitbucket.

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

Шаг 1: Установите Git и подготовьте проект

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

Проверьте, установлен ли Git

Прежде чем использовать Git, проверьте, установлен ли он на вашем компьютере. Скорее всего, он уже есть, особенно если вы пользователь macOS или Linux. Для проверки выполните следующую команду:

$ git --version

Если команда показывает версию Git, значит, его установка завершена, и вы можете создать директорию проекта.

На Windows Git может не добавляться в переменную среды PATH автоматически. В этом случае перезапустите терминал после установки или добавьте путь к Git вручную.

Установите Git на вашу систему

Git предоставляет установщики для Windows, macOS и Linux на своём официальном сайте — это самый простой способ поставить Git на любой компьютер. Поскольку шаги установки различаются в зависимости от операционной системы, руководство ссылается на официальную документацию, а не воспроизводит эти шаги здесь.

Если вам удобнее использовать графический интерфейс, можно установить клиент Git, например GitHub Desktop, Sourcetree или GitKraken, которые автоматически установят Git в процессе настройки.

После установки откройте терминал и убедитесь, что Git доступен:

$ git --version
git version 2.24.0.windows.2

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

Создайте директорию проекта

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

Начните с создания новой папки для проекта:

$ mkdir hello-git/
$ cd hello-git/

Добавьте файл Python с именем main.py внутри папки hello-git/, которую вы только что создали:

def greet(name): return f"Hello, {name}!"
print(greet("World"))

Этот проект станет вашим репозиторием Git. Фактическое содержимое файла на данном этапе не очень важно — его цель просто дать Git файл для отслеживания, пока вы начинаете записывать изменения.

Инициализируйте репозиторий Git

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

Внутри директории проекта выполните следующее:

$ git init
Initialized empty Git repository in /Users/realpython/hello-git/.git/

Эта команда инициализирует ваш репозиторий и сообщает Git, что нужно начать наблюдать за этой папкой. Она создаёт скрытую папку .git/, в которой хранится вся история проекта. Вы не будете взаимодействовать с этой папкой напрямую, но она является движком системы контроля версий Git, хранящим снимки и внутренние настройки.

Проверьте текущее состояние репозитория

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

Чтобы проверить состояние репозитория, выполните следующую команду:

$ git status
On branch main
No commits yet
Untracked files: (use "git add <file>..." to include in what will be committed) main.py
nothing added to commit but untracked files present (use "git add" to track)

Git показывает, какие файлы не отслеживаются или изменены, и готовы ли они к подготовке или коммиту. На данном этапе Git сигнализирует, что файл main.py присутствует в директории проекта.

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

Шаг 2: Создайте первый коммит

Теперь, когда репозиторий настроен, можно начать записывать снимки проекта. На этом шаге вы добавите изменения в индекс (staging area) и создадите первый коммит, изучив, как Git сохраняет и описывает вашу работу с течением времени.

Добавьте файл в индекс

Индекс (staging area) — это что-то вроде контрольного списка изменений, которые вы хотите включить в следующий снимок. В коммит попадут только файлы из этой области.

Чтобы подготовить изменения к коммиту, используйте команду git add, указав имя файла:

$ git add main.py

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

Если нужно добавить сразу несколько файлов, можно воспользоваться такой командой:

$ git add .

Она добавляет в индекс все изменения в текущем каталоге и подкаталогах, избавляя от необходимости добавлять каждый файл по отдельности.

Примечание: хотя git add . удобна, будьте с ней осторожны, особенно на начальном этапе. Эта команда добавляет в индекс всё, что изменилось, включая файлы, которые вы, возможно, не хотите коммитить:

• Временные файлы, созданные редактором
• Файлы конфигурации с личными настройками или паролями
• Большие файлы данных или скомпилированный код

Перед запуском git add . всегда сначала проверяйте git status, чтобы видеть, какие файлы будут добавлены в индекс. Если вы видите файлы, которые не хотите отслеживать, можно либо добавлять файлы по отдельности, либо создать файл .gitignore, чтобы указать Git, какие файлы игнорировать постоянно.

Создайте первый коммит

После того как изменения добавлены в индекс, сохраните их с сообщением коммита:

$ git commit -m "Initial commit"
[main (root-commit) 1a1da40] Initial commit 1 file changed, 4 insertions(+) create mode 100644 main.py

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

Коммит — это сохранённый снимок проекта в определённый момент времени. Он позволяет просматривать, откатывать или безопасно передавать свою работу.

Каждый коммит включает ключевую информацию:

• Хеш коммита (commit hash): уникальный идентификатор (например, 1a1da40), который Git генерирует для каждого коммита
• Автор: ваше имя и адрес электронной почты
• Дата и время: временная метка коммита
• Сообщение коммита: описание того, что изменилось и почему
• Снимок: полное состояние всех отслеживаемых файлов на этот момент

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

$ git status
On branch main
nothing to commit, working tree clean

Это сообщение подтверждает, что все изменения зафиксированы. «Чистое рабочее дерево» (clean working tree) означает, что нет ни неиндексированных, ни незафиксированных изменений — всё сохранено в истории Git.

Пишите понятные сообщения коммитов

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

При написании сообщения коммита держите первую строку короткой (около 50 символов) и сосредоточьтесь на том, что делает изменение. Используйте повелительное наклонение, например «Add feature» или «Fix bug», и будьте конкретны. Сообщения вроде «Add user authentication» гораздо полезнее расплывчатых, таких как «Update code».

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

$ git commit

Когда вы запускаете git commit без -m, вы можете оказаться в Vim — мощном, но нестандартном текстовом редакторе, работающем в терминале. Vim может сбить с толку, если вы с ним не знакомы, потому что он работает иначе, чем обычные текстовые редакторы. Вот как с ним работать:

• Чтобы начать писать, нажмите I для входа в «режим вставки» (insert mode)
• Напишите сообщение коммита. Многострочные сообщения, как правило, следуют такому формату: краткое резюме (50 символов или меньше), затем пустая строка, затем более подробное объяснение
• Чтобы сохранить и выйти, нажмите Esc, затем введите :wq и нажмите Enter
• Чтобы выйти без сохранения, нажмите Esc, затем введите :q! и нажмите Enter

Разберитесь с веткой по умолчанию

Теперь, когда вы сделали первый коммит, можно изучить несколько важных концепций: понимание веток и настройку того, какие файлы Git должен отслеживать.

Ветка (branch) — это независимая линия разработки, позволяющая работать над изменениями, не затрагивая другие версии проекта. Git создаёт ветку по умолчанию при первом коммите. В зависимости от конфигурации Git вы можете видеть «master» вместо «main». В этом руководстве вы будете работать исключительно на этой ветке по умолчанию. Ветки становятся особенно важны позже, когда вы начнёте экспериментировать, исправлять ошибки или работать совместно с другими.

Чтобы показать все локальные ветки и увидеть, на какой из них вы находитесь, используйте эту команду:

$ git branch
* main

Git перечисляет все локальные ветки, а текущая отмечена звёздочкой (*). Это позволяет с первого взгляда понять, какая ветка активна.

Текущую ветку также можно увидеть, выполнив git status. В верхней части вывода Git сообщает, на какой ветке вы находитесь:

On branch main

Это подтверждает то, что вы увидели с помощью git branch, и даёт дополнительный контекст, например статус индексированных или неотслеживаемых файлов.

Игнорируйте файлы, которые не нужно отслеживать

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

Чтобы увидеть это в действии, создайте файл .env для хранения секретного API-ключа:

$ echo "SECRET_KEY=my-secret-key" > .env

Теперь проверьте статус:

$ git status
On branch main
Untracked files: (use "git add <file>..." to include in what will be committed) .env

Git теперь помечает .env как неотслеживаемый файл. Коммит таких файлов — распространённая ошибка безопасности, поскольку чувствительные данные, такие как API-ключи и пароли, никогда не должны попадать в историю репозитория. Файл .gitignore предотвращает это.

Создайте его в папке проекта:

$ touch .gitignore

Затем добавьте несколько распространённых шаблонов игнорирования для Python:

__pycache__/
*.pyc
.env
venv/

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

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

Теперь проверьте статус репозитория:

$ git status
On branch main
Untracked files: (use "git add <file>..." to include in what will be committed) .gitignore

Сам файл .gitignore отображается как неотслеживаемый, потому что Git не начинает автоматически отслеживать новые файлы. Файлы, соответствующие добавленным шаблонам, такие как .env, __pycache__/ или venv/, не будут появляться в списке неотслеживаемых, если они существуют. Это подтверждает, что Git правильно их игнорирует и фокусируется только на файлах, которые вы действительно хотите отслеживать.

Зафиксируйте .gitignore, чтобы он стал частью истории проекта:

$ git add .gitignore
$ git commit -m "Add .gitignore"
[main 3b8c941] Add .gitignore 1 file changed, 4 insertions(+) create mode 100644 .gitignore

По ходу этого руководства вы заметите, что git status — одна из наиболее часто используемых команд Git. Она показывает именно то, что Git видит в данный момент. Пока вы учитесь, возьмите за привычку запускать git status почаще, особенно до и после внесения изменений. Это помогает понять, как Git реагирует на ваши действия, и предотвращает неожиданности, когда вы готовы сделать коммит.

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

Шаг 3: Отслеживание изменений и управление историей проекта

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

Редактирование файла и добавление нового

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

Откройте main.py и обновите вызов функции print(), указав другое имя:

print(greet("Git learner"))

Это изменяет приветственное сообщение, которое отображается при запуске программы.

Большинство проектов содержат несколько файлов. Распространённым дополнением является файл README.md, который кратко объясняет, что делает проект и как им пользоваться.

Создайте файл README.md для документирования проекта:

$ echo "# Greeting Project Tutorial" > README.md
$ echo "A Python program that greets users." >> README.md

Это создаёт файл с простым заголовком и описанием.

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

$ git status
On branch main
Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: main.py
Untracked files: (use "git add <file>..." to include in what will be committed) README.md
no changes added to commit (use "git add" and/or "git commit -a")

При выполнении git status Git разделяет изменённые отслеживаемые файлы и новые, неотслеживаемые файлы. Обратите внимание на разницу: main.py отображается как «modified» (изменён), потому что Git уже отслеживает его, тогда как README.md появляется в разделе «Untracked files» (неотслеживаемые файлы), поскольку это новый, неотслеживаемый файл.

Git не начинает автоматически отслеживать новые файлы. Их необходимо явно добавить с помощью git add.

Просмотр изменений

Git предоставляет инструменты для просмотра точных изменений. Команда git diff помогает проверить правки перед их коммитом.

После изменения файла, до его индексирования с помощью git add, можно увидеть, что именно изменилось:

$ git diff
diff --git a/main.py b/main.py
index da85a46..b053301 100644
--- a/main.py
+++ b/main.py
@@ -1,4 +1,4 @@ def greet(name): return f"Hello, {name}!"
-print(greet("World"))
+print(greet("Git learner"))

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

Обратите внимание, что git diff показывает изменения только в отслеживаемых файлах. Новый файл README.md здесь не отображается, поскольку Git ещё не отслеживает его.

Индексирование изменений

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

$ git add main.py README.md

Или проиндексировать все изменения сразу:

$ git add .

Это подготавливает оба изменения к включению в следующий коммит.

Примечание: после индексирования файлов с помощью git add можно проверить, что проиндексировано и готово к коммиту, выполнив:

$ git diff --staged

Это позволяет ещё раз проверить изменения перед коммитом. Убедившись в правильности проиндексированных изменений, можно записать их в новый коммит.

Коммит обновления

Проиндексировав изменения, вы можете сохранить их в виде нового коммита. Это создаёт ещё один снимок, который дополняет историю проекта.

Сохраните изменения с описательным сообщением коммита:

$ git commit -m "Update greeting message and add README"
[main 6a2f280] Update greeting message and add README 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 README.md

Теперь репозиторий содержит несколько снимков, отражающих эволюцию проекта. Их всегда можно просмотреть следующим образом:

$ git log
commit 6a2f280bcea26a670d58987484ffa115673573eb
Author: Hellen Kokach
Date: Fri Jan 9 18:05:47 2026 +0300
Update greeting message and add README
commit 3b8c941a2d0e5f7b9c1e3d5f7a9b2d4e6f8a0c1
Author: Hellen Kokach
Date: Fri Jan 9 18:03:30 2026 +0300
Add .gitignore
commit 1a1da40bcea26a670d58987484ffa115673573ea
Author: Hellen Kokach
Date: Fri Jan 9 18:02:46 2026 +0300
Initial commit

Это выводит каждый коммит вместе с его идентификатором, автором, временной меткой и сообщением, что позволяет отслеживать изменения, видеть, кто их внёс (при совместной работе), и откатываться при необходимости