Начало работы с Git и GitHub в ваших проектах Python

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

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

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

Установка и настройка Git

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

Мы можем проверить, все ли работает правильно, открыв окно терминала или командной строки и запустив git --version.

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

$ git config --global user.name <"YOUR NAME">
$ git config --global user.email <name@email.com>

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

Как вы скоро узнаете, Git использует концепцию ветвей для управления своими репозиториями. Ветка — это копия папки вашего проекта в определенный момент цикла разработки. Ветвь новых репозиториев по умолчанию называется master или main, в зависимости от вашей текущей версии Git.

Вы можете изменить имя ветки по умолчанию, выполнив следующую команду:

$ git config --global init.defaultBranch <branch_name>

Эта команда установит имя ветки Git по умолчанию на branch_name. Помните, что это просто имя-заполнитель. Вам необходимо указать подходящее имя для вашей установки.

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

# Visual Studio Code
$ git config --global core.editor "code --wait"

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

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

$ git config --global -e

Эта команда откроет глобальный файл .gitconfig в нашем редакторе по умолчанию. Там мы можем исправить любую сделанную нами ошибку или добавить новые настройки. Затем нам просто нужно сохранить файл и закрыть его.

Понимание того, как работает Git

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

Общий рабочий процесс для создания фиксации Git для сохранения разных моментальных снимков состоит из следующих шагов:

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

Как упоминается в третьем шаге, Git использует специальную базу данных, называемую репозиторием. Эта база данных хранится в каталоге вашего проекта в папке с именем .git.

Управление версиями проекта с помощью Git: Основы

В этом разделе мы создадим локальный репозиторий и узнаем, как управлять им с помощью интерфейса командной строки Git (CLI). В macOS и Linux мы можем использовать терминальное приложение по умолчанию, чтобы следовать этому руководству.

В Windows мы рекомендуем использовать Git Bash, который является частью пакета Git For Windows. Перейдите на страницу загрузки Git Bash, получите установщик, запустите его и следуйте инструкциям на экране. Обязательно установите флажок Additional Icons -> On the Desktop, чтобы получить прямой доступ к Git Bash на рабочем столе, чтобы вы могли быстро найти и запустить приложение.

Кроме того, вы также можете использовать командную строку Windows или PowerShell. Однако некоторые команды могут отличаться от команд, используемых в этом руководстве.

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

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

$ mkdir sample_project
$ cd sample_project

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

Чтобы инициализировать репозиторий Git в этой папке, нам нужно использовать команду git init, как в примере ниже:

$ git init
Initialized empty Git repository in /.../sample_project/.git/

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

Проверка статуса проекта

Git предоставляет команду git status, позволяющую определить текущее состояние репозитория Git. Поскольку наша папка sample_project все еще пуста, при запуске git status будет отображаться что-то вроде этого:

$ git status
On branch main

No commits yet

nothing to commit (create/copy files and use "git add" to track)

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

В качестве примера того, насколько полезна команда git status, создайте файл с именем main.py внутри папки проекта, используя следующие команды:

$ touch main.py

$ 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)

С помощью команды touch мы создаем новый файл main.py в папке нашего проекта. Затем снова запускаем git status. На этот раз мы получаем информацию о наличии неотслеживаемого файла с именем main.py. Мы также получаем некоторые основные инструкции о том, как добавить этот файл в наш репозиторий Git. Предоставление этих руководств или инструкций — одна из лучших функций git status.

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

Отслеживание и внесение изменений

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

В нашем примере мы не сделали никаких коммитов в репозиторий Git, поэтому main.py, естественно, не отслеживается. Чтобы начать отслеживать его, запустите команду git add следующим образом:

$ git add main.py

$ git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
    new file:   main.py

Эта команда git add добавила main.py в список отслеживаемых файлов. Теперь пришло время сохранить файл навсегда с помощью команды git commit с соответствующим сообщением о коммите, предоставленным с параметром -m:

$ git commit -m "Add main.py"
[main (root-commit) 5ac6586] Add main.py
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 main.py

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

Мы успешно сделали нашу первую фиксацию, сохранив main.py в нашем репозитории Git. Команде git commit требуется сообщение фиксации, которое мы можем предоставить с помощью параметра -m. Сообщения коммитов должны четко описывать, что мы изменили в нашем проекте.

После коммита наша main ветка полностью чиста, как вы можете заключить из вывода git status.

Теперь давайте снова запустим цикл, изменив main.py, разместив изменения и создав новый коммит. Идите вперед и выполните следующие команды:

$ echo "print('Hello, World!')" > main.py
$ cat main.py
print('Hello, World!')

$ git add main.py

$ git commit -m "Create a 'Hello, World!' script  on  main.py"
[main 2f33f7e] Create a 'Hello, World!' script  on  main.py
 1 file changed, 1 insertion(+)

Команда echo добавляет оператор "print('Hello, World!')" в наш файл main.py. Вы можете подтвердить это добавление с помощью команды cat, которая выводит содержимое одного или нескольких целевых файлов. Вы также можете открыть main.py в своем любимом редакторе и обновить файл там, если хотите.

Мы сделали два коммита в нашем репозитории Git. Мы можем перечислить нашу историю коммитов с помощью команды git log следующим образом:

$ git log --oneline
2f33f7e (HEAD -> main) Create a 'Hello, World!' script  on  main.py
5ac6586 Add main.py

Команда git log позволяет нам перечислить все наши предыдущие коммиты. В этом примере мы использовали параметр --oneline для перечисления коммитов в одной строке. Эта команда переводит нас в выделенное пространство вывода. Чтобы покинуть это место, мы можем нажать букву Q на клавиатуре.

Использование файла .gitignore для пропуска ненужных файлов

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

$ python -m venv venv

После того, как мы добавили виртуальную среду Python в папку нашего проекта, мы можем снова запустить git status, чтобы проверить состояние репо:

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

nothing added to commit but untracked files present (use "git add" to track)

Теперь папка venv/ отображается как неотслеживаемый файл в нашем репозитории Git. Нам не нужно отслеживать эту папку, потому что она не является частью кодовой базы нашего проекта. .gitignore -  инструмент для работы над проектом. Итак, нам нужно игнорировать эту папку. Для этого мы можем добавить папку в файл .gitignore.

Идите вперед и создайте файл .gitignore в папке проекта. Добавьте в него папки venv/ и запустите git status:

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

nothing added to commit but untracked files present (use "git add" to track)

Теперь git status не указывает venv/ как неотслеживаемый файл. Это означает, что Git игнорирует эту папку. Если мы посмотрим на вывод, то увидим, что .gitignore теперь указан как неотслеживаемый файл. Мы должны закоммитить наши файлы .gitignore в репозиторий Git. Это избавит других разработчиков, работающих с нами, от необходимости создавать свои собственные локальные файлы .gitignore.

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

Работа с ветками в Git

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

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

1. main или master ветвь, которая содержит основную линию разработки.
2. Ветка develop, содержащая последние разработки
   
3. Одна или несколько feature ветви, которые содержат изменения, предназначенные для добавления новых функций.
   
4. Одна или несколько bugfix ветвей, которые содержат изменения, предназначенные для исправления критических ошибок.

Однако какую модель ветвления использовать, зависит от вас. В следующих разделах мы узнаем, как управлять ветвями с помощью Git.

Создание новых ветвей

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

Для начала давайте создадим новую ветку hello в нашем репозитории Git в папке sample_project. Для этого мы можем использовать команду git branch, за которой следует имя ветки:

$ git branch hello
$ git branch --list
* main
  hello

Первая команда создает новую ветку в нашем репозитории Git. Вторая команда позволяет нам перечислить все ветки, которые в настоящее время существуют в нашем репозитории. Опять же, мы можем нажать букву Q на клавиатуре, чтобы вернуться к приглашению терминала.

Звездочка обозначает текущую активную ветвь, которая в примере является main. Мы хотим работать над hello, поэтому нам нужно активировать эту ветку. В терминологии Git нам нужно проверить до hello.

Перевод в новую ветвь

Хотя мы только что создали новую ветку, для того, чтобы начать работать с ней, нам нужно переключиться на нее или выйти из нее с помощью команды git checkout следующим образом:

$ git checkout hello
Switched to branch 'hello'

$ git branch --list
  main
* hello

$ git log --oneline
2f33f7e (HEAD -> hello, main) Create a 'Hello, World!' script  on  main.py
5ac6586 Add main.py

Команда git checkout принимает в качестве аргумента имя существующей ветки. Как только мы запустим команду, Git перенаправит нас в целевую ветку.

Как видите, git branch --list указывает, на какой ветке мы сейчас находимся, помещая символ * перед соответствующим именем ветки. Если мы проверим историю коммитов с помощью git log --oneline, то получим то же самое, что и из main, потому что hello — это его копия.

Давайте внесем некоторые изменения в наш проект и создадим еще один коммит. Идите вперед и выполните следующие команды:

$ echo "print('Welcome to PythonGUIs!')" >> main.py
$ cat main.py
print('Hello, World!')
print('Welcome to PythonGUIs!')

$ git add main.py
$ git commit -m "Extend our 'Hello, World' program with a welcome message."
[hello be62476] Extend our 'Hello, World' program with a welcome message.
 1 file changed, 1 insertion(+)

Последняя команда зафиксировала наши изменения в ветке hello. Если мы сравним историю коммитов обеих веток, то увидим разницу:

$ git log --oneline -1
be62476 (HEAD -> hello) Extend our 'Hello, World' program with a welcome message.

$ git checkout main
Switched to branch 'main'

$ git log --oneline -1
2f33f7e (HEAD -> main) Create a 'Hello, World!' script  on  main.py

В этом примере мы сначала запускаем git log --oneline с -1 в качестве аргумента. Этот аргумент говорит Git предоставить нам только последний коммит в истории коммитов активной ветки. Чтобы проверить историю коммитов main, нам сначала нужно проверить эту ветку. Затем мы можем запустить ту же команду git log.

Теперь скажем, что мы довольны изменениями, внесенными в наш проект в ветке hello, и мы хотим обновить main с учетом этих изменений. Как мы можем это сделать? Нам нужно объединить hello с main.

Объединение двух ветвей вместе

Чтобы добавить коммиты, которые мы сделали в отдельной ветке, обратно в другую ветку, мы можем запустить то, что известно как слияние. Например, предположим, что мы хотим объединить новые коммиты в hello с main. В этом случае нам сначала нужно переключиться обратно на main, а затем запустить команду git merge, используя hello в качестве аргумента:

$ git checkout main
Already on 'main'

$ git merge hello
Updating 2f33f7e..be62476
Fast-forward
 main.py | 1 +
 1 file changed, 1 insertion(+)

Чтобы объединить ветку с другой веткой, нам сначала нужно проверить ветку, которую мы хотим обновить. Затем мы можем запустить git merge. В приведенном выше примере мы сначала проверяем файл main. Оказавшись там, мы можем объединить hello.

Удаление неиспользуемых ветвей

Как только мы закончим работу в данной ветке, мы можем удалить всю ветку, чтобы сохранить наше репо как можно более чистым. Следуя нашему примеру, теперь, когда мы объединили hello с main, мы можем удалить hello.

Чтобы удалить ветку из репозитория Git, мы используем команду git branch с параметром --delete. Чтобы успешно выполнить эту команду, обязательно переключитесь на другую ветку перед:

$ git checkout main
Already on 'main'

$ git branch --delete hello
Deleted branch hello (was be62476).

$ git branch --list
* main

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

Использование GUI-клиента для Git

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

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

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

Управление проектом с помощью GitHub

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

В следующих разделах мы узнаем, как создать удаленный репозиторий на GitHub, а затем отправить в него наш существующий локальный репозиторий. Прежде чем мы это сделаем, зайдите на GitHub.com и создайте там учетную запись, если у вас ее еще нет. Если у вас есть учетная запись GitHub, вы можете настроить подключение к этой учетной записи, чтобы использовать ее с Git.

Настройка безопасного подключения к GitHub

Чтобы работать с GitHub через команду git, нам нужно иметь возможность аутентифицировать себя. Есть несколько способов сделать это. GitHub автоматически создает уникальный секрет для использования в рабочем процессе. Однако рекомендуется использовать SSH. Первым шагом в этом процессе является создание ключа SSH, что вы можете сделать с помощью следующей команды:

$ ssh-keygen -t ed25519 -C "GitHub - name@email.com"

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

Далее нам нужно скопировать содержимое нашего файла id_ed25519.pub. Для этого вы можете запустить следующую команду:

$ cat ~/.ssh/id_ed25519.pub

Выберите вывод команды и скопируйте его. Затем перейдите на страницу настроек GitHub и Settings опцию SSH и GPG keys. Там выберите «New SSH key», задайте описательный заголовок для ключа, убедитесь, что для параметра «Тип ключа» установлено значение «Key Type», и, наконец, вставьте содержимое id_ed25519.pub в поле «Key». Наконец, нажмите кнопку «Add SSH key».

Теперь мы можем проверить наше соединение, выполнив следующую команду:

$ ssh -T git@github.com
The authenticity of host 'github.com (IP ADDRESS)' can not be established.
ECDSA key fingerprint is SHA256:p2QAMXNIC1TJYWeIOttrVc98/R1BUFWu3/LiyKgUfQM.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Обязательно проверьте, соответствует ли отпечаток ключа, показанный в выходных данных, отпечатку пальца открытого ключа GitHub. Если он совпадает, введите yes и нажмите Enter для подключения. В противном случае не подключайтесь.

В случае успешного подключения мы получим такое сообщение:

Hi USERNAME! You have successfully authenticated, but GitHub does not provide shell access.

Вы успешно подключились к GitHub через SSH, используя безопасный ключ SSH. Теперь пришло время начать работать с GitHub.

Создание и настройка репозитория GitHub

Теперь, когда у вас есть учетная запись GitHub с правильным SSH-соединением, давайте создадим удаленный репозиторий на GitHub, используя его веб-интерфейс. Перейдите на страницу GitHub и щелкните значок + рядом с вашим аватаром в правом верхнем углу. Затем выберите New repository.

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

Затем установите для репозитория видимость Private, чтобы никто другой не мог получить доступ к коду. Наконец, нажмите кнопку «Create repository» в конце страницы.

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

$ git remote add origin git@github.com:USERNAME/sample_project.git

Эта команда добавляет новый удаленный репозиторий с именем origin в наш локальный репозиторий Git.

Git позволяет нам добавить несколько удаленных репозиториев в один локальный с помощью команды git remote add. Это позволяет нам иметь несколько удаленных копий вашего локального репозитория Git.

Отправка локального репозитория Git на GitHub

Имея новый и пустой репозиторий GitHub, мы можем продолжить и отправить содержимое нашего локального репозитория в его удаленную копию. Для этого мы используем команду git push, предоставляющую целевое удаленное репо и локальную ветку в качестве аргументов:

$ git push -u origin main
Enumerating objects: 9, done.
Counting objects: 100% (9/9), done.
Delta compression using up to 8 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (9/9), 790 bytes | 790.00 KiB/s, done.
Total 9 (delta 0), reused 0 (delta 0), pack-reused 0
To github.com:USERNAME/sample_project.git
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.

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

Обратите внимание: если вы не добавите параметр -u, Git спросит, что вы хотите сделать. Безопасный обходной путь — скопировать и вставить команды, которые предлагает GitHub, чтобы не забыть -u.

Теперь давайте перейдем к нашему браузеру и обновим страницу GitHub. Там мы увидим все файлы нашего проекта и историю коммитов.

Теперь мы можем продолжить разработку нашего проекта и делать новые коммиты локально. Чтобы отправить наши коммиты в удаленную ветку main, нам просто нужно запустить git push. На этот раз нам не нужно использовать удаленное имя или имя ветки, потому что мы уже установили main для отслеживания origin/main.

Извлечение контента из репозитория GitHub

Мы можем выполнять базовое редактирование файлов и делать коммиты внутри самого GitHub. Например, если мы щелкнем файл main.py, а затем щелкнем значок карандаша в верхней части файла, мы можем добавить еще одну строку кода и зафиксировать эти изменения в удаленной ветке main непосредственно на GitHub.

Идем дальше и добавляем оператор print("Your Git Tutorial is Here...") в конец main.py. Затем перейдите в конец страницы и нажмите кнопку Commit changes. Это создает новую фиксацию в вашем удаленном репозитории.

Эта удаленная фиксация не появится в вашей локальной истории коммитов. Чтобы загрузить его и обновить локальную ветку main, используйте команду git pull:

$ git pull
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 696 bytes | 174.00 KiB/s, done.
From github.com:USERNAME/sample_project
   be62476..605b6a7  main       -> origin/main
Updating be62476..605b6a7
Fast-forward
 main.py | 1 +
 1 file changed, 1 insertion(+)

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

Если мы хотим загрузить удаленную ветку, не обновляя локальную, мы можем использовать команду [git fetch](https://git-scm.com/docs/git-fetch). Эта практика дает нам возможность просмотреть изменения и зафиксировать их в нашем локальном репозитории, только если они выглядят правильно.

Например, обновите удаленную копию main.py, добавив еще один оператор, такой как print("Let's go!!"). Зафиксируйте изменения. Затем вернитесь в свой локальный репозиторий и выполните следующую команду:

$ git fetch
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 731 bytes | 243.00 KiB/s, done.
From github.com:USERNAME/sample_project
   605b6a7..ba489df  main       -> origin/main

Эта команда загрузила последние изменения из origin/main в наш локальный репозиторий. Теперь мы можем сравнить удаленную копию main.py с локальной копией. Для этого мы можем использовать команду git diff следующим образом:

$ git diff main origin/main
diff --git a/main.py b/main.py
index be2aa66..4f0e7cf 100644
--- a/main.py
+++ b/main.py
@@ -1,3 +1,4 @@
 print('Hello, World!')
 print('Welcome to PythonGUIs!')
 print("Your Git Tutorial is Here...")
+print("Let's go!!")

В выводе команды вы можете видеть, что удаленная ветвь добавляет строку, содержащую print("Let's go!!"), в конец main.py. Это изменение выглядит хорошо, поэтому мы можем использовать git pull для автоматической фиксации изменения.

Изучение альтернатив GitHub

Хотя GitHub является самым популярным общедоступным сервером Git и используемой платформой для совместной работы, он далеко не единственный. GitLab.com и BitBucket — популярные коммерческие альтернативы, подобные GitHub. Хотя у них есть платные планы, оба предлагают бесплатные планы с некоторыми ограничениями для отдельных пользователей.

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

При желании вы также можете запустить свой собственный сервер Git. Хотя вы можете просто использовать для этого базовый git, программное обеспечение, такое как GitLab Community Edition (CE) и Forgejo, предоставляет вам как преимущества запуска собственного сервера, так и опыт использования службы, такой как GitHub.

Вывод

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

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