🐍🤖​ Как использовать GitHub Copilot вместе с Python: подробная инструкция

Что такое GitHub Copilot

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

В этом туториале вы узнаете, как:

1. Установить расширение GitHub Copilot в редактор кода.
2. Превратить описание задачи на естественном языке в рабочий код.
3. Выбрать между несколькими альтернативными вариантами интеллектуального автозавершения кода.
4. Исследовать незнакомые фреймворки и языки программирования.
5. Научить GitHub Copilot использовать ваш собственный API.
6. Практиковать разработку через тестирование с помощью виртуального парного программирования в режиме реального времени.

Чтобы продолжить работу с этим руководством, вам потребуется личная учетная запись GitHub и редактор кода, например, Visual Studio Code, или интегрированная среда разработки, например, PyCharm.

Бесплатная загрузка: Нажмите здесь, чтобы загрузить бесплатную памятку с сочетаниями клавиш, чтобы сделать программирование с помощью GitHub Copilot еще быстрее.

Приступаем к работе с GitHub Copilot на Python!

GitHub Copilot — это первый коммерческий продукт, основанный на системе OpenAI Codex, который может переводить естественный язык в код на более чем дюжине языков программирования в режиме реального времени. Сам OpenAI Codex является потомком языковой модели глубокого обучения GPT-3. Нейронная сеть Codex обучалась как на текстах, так и на сотнях миллионов общедоступных репозиториев кода, размещенных на GitHub.

GitHub Copilot понимает несколько языков программирования и многие человеческие языки, а это значит, что вы не ограничены только английским языком. Например, если вы являетесь носителем испанского языка, вы можете общаться с GitHub Copilot на своем родном языке.

Подпишитесь на GitHub Copilot

Чтобы включить GitHub Copilot, перейдите к billing settings в своем профиле GitHub и прокрутите вниз, пока не увидите соответствующий раздел. К сожалению, эта услуга не является бесплатной для большинства людей. На момент написания эта услуга стоила десять долларов в месяц или сто долларов в год при оплате авансом. Вы можете воспользоваться шестидесятидневным пробным периодом, ничего не платя, но только после предоставления платежной информации.

Студенты и специалисты по сопровождению открытого исходного кода могут получить бесплатную подписку на GitHub Copilot. Если вам повезло, то после включения сервиса вы увидите следующую информацию:

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

Для получения подробных инструкций по настройке и управлению вашей подпиской на GitHub следуйте инструкциям официальной документации. Далее вы узнаете, как установить расширение GitHub Copilot для Visual Studio Code. Если вместо этого вы предпочитаете использовать GitHub Copilot с PyCharm, пропустите этот шаг и переходите сразу к изучению.

Установите Visual Studio Code Extension

Поскольку Microsoft владеет GitHub, неудивительно, что их редактор Visual Studio Code стал первым инструментом, получившим поддержку GitHub Copilot. Существует несколько способов установки расширений в Visual Studio Code, но, вероятно, самый быстрый из них — открыть панель при помощи Ctrl+P или Cmd+P, а затем ввести следующую команду:

        ext install GitHub.copilot
    

Когда вы подтвердите это, нажав Enter, оно установит расширение и предложит вам перезагрузить редактор после этого.

Кроме того, вы можете нажать на значок Extensions в Activity Bar, расположенного в левой части окна, и попробовать найти расширение GitHub Copilot в Visual Studio Marketplace :

Вы также можете отобразить представление Extensions в Visual Studio Code напрямую, используя соответствующее сочетание клавиш.

После завершения установки Visual Studio Code попросит вас войти в GitHub, чтобы предоставить ему доступ к вашему профилю GitHub, который требуется вашему новому расширению:

Visual Studio Code необходимо знать, кто вы, чтобы подтвердить статус подписки GitHub Copilot. Однако предоставление доступа к вашему профилю GitHub также позволит редактору читать ваши private-репозитории. Если вы передумаете, вы можете отозвать эту авторизацию в любое время, зайдя в настройки своего профиля GitHub и найдя GitHub для VS Code в Authorized OAuth Apps.

Чтобы сделать работу с GitHub Copilot в Visual Studio Code еще более продуктивной, вот наиболее распространенные сочетания клавиш, которые стоит запомнить:

Если у вас возникли проблемы с работой сочетаний клавиш по умолчанию, попробуйте определить свои собственные комбинации клавиш в Visual Studio Code. Это может быть особенно полезно, если вы работаете с раскладкой клавиатуры, отличной от американской.

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

Вот и все! Все готово для использования расширения GitHub Copilot в Visual Studio Code. Но если вы предпочитаете использовать GitHub Copilot с PyCharm, то читайте дальше, чтобы узнать, как это сделать.

Установите плагин PyCharm

PyCharm — одна из интегрированных сред разработки, предоставляемых JetBrains и использующих общий плагин GitHub Copilot. Вы можете установить этот подключаемый модуль, открыв Settings в своей среде IDE и выбрав Plugins из списка параметров. Затем на вкладке Marketplace найдите плагин GitHub Copilot и нажмите кнопку Install рядом с ним:

После установки плагина вам будет предложено перезапустить IDE. Когда вы это сделаете, вам нужно будет войти в GitHub, выбрав Tools в меню PyCharm, затем GitHub Copilot и Login to GitHub:

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

Как и в случае с Visual Studio Code, вам потребуется авторизовать подключаемый модуль PyCharm, чтобы подтвердить вашу личность и соответствующий статус подписки GitHub Copilot. Однако PyCharm использует API GitHub вместо токена OAuth, поэтому процесс авторизации выглядит немного иначе:

Обратите внимание, что предоставление доступа к вашему профилю GitHub позволит плагину получать информацию из вашего профиля, например, адрес электронной почты, и читать ваши private-репозитории. Если вы передумаете, то можете отозвать эту авторизацию в любое время, зайдя в настройки своего профиля GitHub и найдя GitHub Copilot Plugin в Authorized GitHub Apps.

Чтобы сделать работу с GitHub Copilot в PyCharm еще более продуктивной, вот наиболее распространенные сочетания клавиш, которые стоит запомнить:

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

Вот и все! Все готово для использования плагина GitHub Copilot в PyCharm.

Передайте бразды правления GitHub Copilot

Чтобы проверить, работает ли GitHub Copilot должным образом в Visual Studio Code, создайте новый текстовый файл, выберите Python в качестве базового языка программирования и начните писать образец сигнатуры функции, например hello():

Как только вы вводите двоеточие : в конце первой строки, чтобы ввести новый блок кода, GitHub Copilot заполняет за вас предлагаемое тело функции. Пока вы не примете его, нажав Tab, или не отклоните его с помощью Esc, он будет отображаться серым шрифтом. Предлагаемый код вызывает функцию print() для вывода текста Hello World на экран в этом случае. Хотя это не было особо впечатляющим, это подтверждает, что GitHub Copilot действительно работает правильно.

Работа с GitHub Copilot в PyCharm практически такая же, как и в других редакторах кода. Чтобы убедиться, что установка плагина прошла успешно, попробуйте другой пример. Начните писать сигнатуру функции, имя которой может указывать на то, что вы хотите сложить два числа, например, add(a, b):

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

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

Синтезируйте код Python из естественного языка

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

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

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

Используйте комментарии в Python для описания проблемы

Хотя влиятельные фигуры в мире программирования, такие как Роберт С. Мартин, считают комментарии к коду антишаблоном, комментарии иногда могут быть полезны для объяснения того, почему определенный фрагмент кода выглядит так, а не иначе. Обычно вы пишете комментарии для себя в будущем или своих товарищей по команде, работающих над той же кодовой базой.

Когда вы добавляете GitHub Copilot в «общую смесь», он становится еще одним потенциальным чтецом ваших комментарий к коду. Рассмотрим следующий однострочный комментарий на языке Python, описывающий классическую программу Hello, World!:

        # Print "Hello, World!"
    

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

        print("Hello, World!")
    

Это почти то же самое предложение, которое вы получили, когда проверяли расширение Visual Studio Code, написав функцию заглушки hello(). Однако на этот раз вы получите немного другой результат. GitHub Copilot понимает, что вы хотите рассматривать цитируемый фрагмент вашего комментария как буквальный текст, а не как инструкцию.

Очевидно, это было слишком просто для GitHub Copilot. Как насчет того, чтобы поднять планку, запросив более конкретный результат? Например, вы можете напечатать Hello, World! в обратном порядке на испанском языке:

        # Print "Hello, World!" backward in Spanish.
    

Вы увидите новые предложения после обновления панели GitHub Copilot в редакторе. Их количество и качество могут меняться каждый раз, когда вы запускаете GitHub Copilot. Лучший результат, который вы получите в случае этого конкретного комментария, это:

        print("¡Hola, mundo!"[::-1])
    

Вот это впечатляет! GitHub Copilot делает это, генерируя не только правильный, но и Pythonic-код, который опытные питонисты написали бы сами. Предложения станут еще интереснее, если вы добавите больше комментариев.

Добавьте больше комментариев, чтобы увеличить сложность задачи

Использование однострочного комментария для описания проблемы — это хорошо, но вы не можете упаковать в него очень много контента. К счастью, можно объединить несколько последовательных комментариев в логическую и связную историю, которую GitHub Copilot будет рассматривать как единое целое. Лучше всего помещать полное законченное предложение в каждую строку, не разрывая ее, но при желании вы можете включить явную обратную косую черту \ в середине предложения, чтобы обозначить разрыв строки:

        # Ask the user to provide a line of text.
# Scan the text for the following mildly offensive words: \
# arse, bloody, damn, dummy.
# If you find any, then replace its letters with asterisks \
# except for the first letter in each offensive word.
# Print the resulting text.

def main():
    

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

        def main():
    text = input("Enter a line of text: ")
    offensive_words = ["arse", "bloody", "damn", "dummy"]
    for word in offensive_words:
        if word in text:
            text = text.replace(word, word[0] + "*" * (len(word) - 1))
    print(text)
    

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

При вызове функции main() вы сможете оценить, насколько хорошо работает сгенерированный код:

Разве это не удивительно? Вы дали GitHub Copilot описание задачи на естественном языке, и он нашел именно то решение, которое подходит именно вам.

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

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

Подавляющее большинство кода, который предлагает GitHub Copilot, никогда раньше не встречалось. Наше последнее внутреннее исследование показывает, что примерно в 1% случаев подсказка может содержать фрагменты кода длиннее ~150 символов, соответствующих обучающему набору. (Источник)

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

Решите головоломку из контеста по программированию

Чтобы проверить истинную мощь GitHub Copilot, вы можете скопировать и вставить фрагмент текстового описания задачи по программированию и посмотреть, как она справится. Например, почему бы вам не взять первую часть головоломки Sonar Sweep из первого дня календаря Advent of Code на 2021 год:

        # For example, suppose you had the following report:
#
# 199
# 200
# 208
# 210
# 200
# 207
# 240
# 269
# 260
# 263
#
# (...)
#
# In this example, there are 7 measurements that are larger \
# than the previous measurement.
#
# How many measurements are larger than the previous measurement?

def solve(measurements):
    

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

        def solve(measurements):
    count = 0
    for i in range(1, len(measurements)):
        if measurements[i] > measurements[i - 1]:
            count += 1
    return count
    

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

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

        def solve(measurements):
    return sum(1 for x, y in zip(measurements, measurements[1:]) if y - x > 0)

    

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

Теперь вы знаете, как генерировать код на естественном языке, используя один или несколько комментариев Python. Однако, как инженер-программист, вы, вероятно, еще больше оцените контекстные подсказки по коду.

Получите еще больше умных подсказок по завершению кода

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

Позвольте GitHub Copilot читать ваши мысли

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

Например, конкретная функция 𝑥 2 + 2𝑥 – 3 имеет такие значения коэффициентов: 𝑎 = 1, 𝑏 = 2, 𝑐 = -3, которые можно использовать для вычисления так называемого дискриминанта, часто обозначаемого греческой буквой дельта:

В этом случае дискриминант функции равен шестнадцати (Δ = 16), когда вы заменяете буквы 𝑎, 𝑏 и 𝑐 соответствующими значениями в формуле выше. В зависимости от знака дискриминанта ваша квадратичная функция может иметь два, один или вообще не иметь корней:

Поскольку дискриминант, вычисленный ранее, является положительным числом, и равен 16, ваша квадратичная функция имеет ровно два корня: 𝑥₁= -3 и 𝑥₂ = 1, если вы примените приведенные выше формулы. Включение любого из них в вашу квадратичную функцию в качестве значения переменной 𝑥 заставляет функцию возвращать ноль. Корни функции – это точки, в которых соответствующая парабола пересекает горизонтальную ось при построении графика.

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

        def find_roots(a, b, c):
    

Через некоторое время GitHub Copilot начнет давать вам подсказки. Если повезет, то одна из них будет поразительно точной:

        def find_roots(a, b, c):
    d = b**2 - 4 * a * c
    if d < 0:
        return None
    elif d == 0:
        return -b / (2 * a)
    else:
        return (-b + d**0.5) / (2 * a), (-b - d**0.5) / (2 * a)
    

Функция вычисляет дискриминант по правильной формуле и сохраняет результат во вспомогательной переменной. В зависимости от знака дискриминанта он может возвращает None, одно корневое значение или кортеж, состоящий из двух корневых значений, и все они вычисляются правильно. Обратите внимание, что предлагаемое решение использует оператор возведения в степень (**) для вычисления квадратного корня дискриминанта. Это позволяет избежать импорта функции sqrt()из math-модуля Python.

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

Предоставьте контекст, чтобы получать лучшие подсказки

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

Рассмотрим функцию 𝑥²+ 1, дискриминант которой отрицателен, что указывает на отсутствие корней. Отсутствие корней можно подтвердить графически, построив параболу функции, которая нигде не пересекает горизонтальную ось. Однако у той же функции есть два комплексных корня: 𝑥₁=-𝑖 и 𝑥₂ = 𝑖, где 𝑖 — мнимая единица , которая при возведении в квадрат дает -1: 𝑖²=-1.

Как вы можете попросить GitHub Copilot изменить реализацию, чтобы вы получили комплексные корни вместо настоящих?

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

        import cmath

def find_roots(a, b, c):
    """Return a tuple of complex numbers."""
    

Здесь вы импортируете cmath-модуль, который является сложным аналогом модуля math. Он содержит функцию cmath.sqrt(), которая может вычислить квадратный корень из отрицательного числа, однако math.sqrt() в таком случае вызывает ошибку:

        >>> import cmath
>>> cmath.sqrt(-1)
1j

>>> import math
>>> math.sqrt(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error
    

Квадратный корень -1 в комплексной области дает мнимую единицу, которую Python называет 1j. Вы можете прочитать больше об использовании комплексных чисел в Python, чтобы узнать, почему он использует букву j вместо i-обозначения мнимой единицы.

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

С добавлением этих двух небольших подсказок GitHub Copilot теперь будет генерировать другую реализацию для той же сигнатуры функции:

        import cmath

def find_roots(a, b, c):
    """Return a tuple of complex numbers."""
    d = (b**2) - (4 * a * c)
    x1 = (-b + cmath.sqrt(d)) / (2 * a)
    x2 = (-b - cmath.sqrt(d)) / (2 * a)
    return x1, x2
    

Он вычисляет дискриминант по-прежнему, но больше не проверяет его знак. Вместо этого, функция вычисляет два комплексных корня, используя функцию cmath.sqrt(), как вы и хотели. Вы можете протестировать свою новую функцию в Python REPL, чтобы проверить, правильно ли функция вычисляет оба комплексных корня:

        >>> import cmath

>>> def find_roots(a, b, c):
...     """Return a tuple of complex numbers."""
...     d = (b**2) - (4 * a * c)
...     x1 = (-b + cmath.sqrt(d)) / (2 * a)
...     x2 = (-b - cmath.sqrt(d)) / (2 * a)
...     return x1, x2
...
>>> find_roots(1, 0, 1)  # Function f(x) = x² + 1
(1j, -1j)

>>> 1j**2 + 1
0j

>>> (-1j)**2 + 1
0j
    

Этот код работает блестяще! Функция x² + 1 возвращает 0 для двух комплексных корней: 1j и -1j.

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

Воспользуйтесь преимуществами творчества GitHub Copilot

Сколько раз вы проектировали новый тип данных только для того, чтобы застрять на выяснении правильных атрибутов или их реализации? С GitHub Copilot вы можете сесть и расслабиться, пока он изобретает для вас новые атрибуты, методы и свойства буквально из воздуха по нажатию файла Tab.

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

GitHub Copilot немедленно выбирает следующий, наиболее вероятный атрибут .last_name, а затем .age. Однако вы знаете, что возраст человека со временем меняется, поэтому вместо этого вы записываете дату его рождения. Следующее логичное предложение от GitHub Copilot — метод, вычисляющий возраст человека на основе текущей даты. Когда вы определяете новое свойство, оно аккуратно завершает описание тела, объединяя имя и фамилию.

В конце концов, вот результат, который вы получите всего за несколько нажатий клавиш в редакторе кода:

        from dataclasses import dataclass
from datetime import date

@dataclass
class Person:
    first_name: str
    last_name: str
    birth_date: date

    def age(self):
        return (date.today() - self.birth_date).days // 365

    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"
    

Станьте полиглотом программирования с личным переводчиком

Нередко в одном файле смешиваются несколько языков, таких как HTML (язык разметки гипертекста), CSS, JavaScript, язык шаблонов Django и Python. К счастью, GitHub Copilot знает более десятка языков программирования, еще больше фреймворков и несколько человеческих языков. У него нет проблем с переключением между ними на ходу в зависимости от контекста, и все это без прерывания вашего потока.

Например, вы можете определить переменную Python для хранения SQL-запроса, который возвращает пользователей по совпадению имен. Пока вы используете правильные слова в имени вашей переменной, вы получаете хорошие подсказки, такие, как это:

Обратите внимание, как вы получаете отдельные строки отдельно поэтапно, потому что вы определили многострочный строковый литерал, используя тройную кавычку ("""). Результат, показанный на видео выше, выглядит следующим образом:

        query_users_by_first_or_last_name = """
SELECT * FROM users
WHERE first_name LIKE %s OR last_name LIKE %s
"""
    

На первый взгляд, запрос выглядит нормально, хотя GitHub Copilot сделал некоторые предположения относительно имени вашей таблицы и двух столбцов для поиска. Тем не менее приятно видеть, что он создает подготовленный оператор, а не простую строку с SQL-запросом, что помогает предотвратить SQL-инъекции.

Хорошо, к этому моменту вы достаточно освоились с GitHub Copilot. Но нам предстоит охватить еще много материала!

Практика парного программирования с виртуальным напарником

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

К преимуществам парного программирования относятся:

1. Более высокое качество производимого кода.
2. Лучшее общее понимание кодовой базы в команде.
3. Знание и обмен лучшими практиками.

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

Тем не менее, GitHub Copilot действительно хорошо помогает повысить вашу производительность, в чем вы скоро убедитесь.

Создание образцов данных для тестирования

Во время разработки вам часто приходится думать об образцах данных для ваших тестов, документации или настройках по умолчанию. Если вы ничего не понимаете, на помощь приходит GitHub Copilot. Например, вспомните класс Person, который вы определили ранее:

        from dataclasses import dataclass
from datetime import date

@dataclass
class Person:
    first_name: str
    last_name: str
    birth_date: date

    def age(self):
        return (date.today() - self.birth_date).days // 365

    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"
    

Теперь предположим, что вам нужно создать несколько экземпляров этого класса для представления сотрудников компании. Пока вы все еще редактируете тот же файл или импортируете класс Person из другого модуля, вы можете использовать GitHub Copilot для заполнения списка сотрудников. Объявите пустой список Python, используя выразительное имя переменной, и нажмите Enter сразу после открывающей квадратной скобки ([), чтобы вызвать подсказку:

        employees = [
    

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

        employees = [
    Person("John", "Smith", date(1970, 1, 1)),
    Person("Jane", "Doe", date(1980, 1, 1)),
    Person("Joe", "Doe", date(1990, 1, 1)),
    Person("Jack", "Doe", date(2000, 1, 1)),
    Person("Jill", "Doe", date(2010, 1, 1)),
    Person("Jana", "Doe", date(2020, 1, 1)),
]

    

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

Пожелайте, чтобы тестовый пример появился волшебным образом

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

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

        def test_should_not_be_able_to_set_full_name():
    

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

        def test_should_not_be_able_to_set_full_name():
    person = Person("John", "Doe", date(1980, 1, 1))
    with pytest.raises(AttributeError):
        person.full_name = "Jane Doe"
    

Как ни странно, GitHub Copilot предпочитает внешнюю библиотеку pytest, которую вы должны установить и импортировать вручную, а не встроенный модуль unittest, доступный в стандартной библиотеке.

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

Разработка на основе тестовых упражнений (TDD)

Если вы раньше не практиковали TDD, ознакомьтесь с учебным пособием Build a Hash Table in Python With TDD, чтобы изучить практический пошаговый ускоренный курс по разработке через тестирование.

Вкратце процесс можно разделить на три этапа:

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

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

Хорошо, как насчет того, чтобы воспроизвести реализацию HashTable из упомянутого выше руководства, используя GitHub Copilot в качестве виртуального напарника-программиста? Создайте два пустых файла Python рядом друг с другом в одной папке:

        src/
├── hashtable.py
└── test_hashtable.py
    

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

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

Напомним, что это два тестовых примера, которые вы только что написали, чтобы проверить, можете ли вы создать хеш-таблицу с начальной емкостью или без нее:

        # test_hashtable.py

from hashtable import HashTable

def test_should_create_hashtable():
    assert HashTable() is not None

def test_should_create_hashtable_with_capacity():
    assert HashTable(capacity=10) is not None
    

На их основе GitHub Copilot сгенерировал следующую реализацию хэш-таблицы:

        # hashtable.py

class HashTable:
    def __init__(self, capacity=10):
        self.capacity = capacity
        self.buckets = [None] * capacity
        self.size = 0
    

Метод инициализатора устанавливает емкость по умолчанию, равную десяти на случай, если кто-то создаст хеш-таблицу без каких-либо аргументов, решение, которое определяется вашим первым тестовым примером. Затем емкость сохраняется в атрибуте экземпляра. Обратите внимание, что GitHub Copilot правильно распознал разницу между размером хеш-таблицы и ее емкостью. Также предполагалась классическая реализация хэш-таблицы, основанная на раздельной цепочке путем создания пустых сегментов.

Хотя GitHub Copilot, возможно, не так хорош, но он делает поистине фантастическую работу в качестве виртуального помощника, отвечая на ваши вопросы. Как будто кто-то ищет в Google или Stack Overflow решение вашей уникальной проблемы, но при этом оно встроенно в редактор кода именно там, где вам это нужно!

Ditch Stack Overflow для мгновенных контекстно-зависимых решений

Интернет полон шуток о чрезмерном использовании таких сайтов, как Stack Overflow или Google, для поиска ответов на вопросы программиста. Например, были пародии на обложки популярных книг О'Рейли, таких как знаменитая «Копируем и вставляем с Stack Overflow»:

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

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

Никогда больше не думайте о шаблонном коде

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

Например, получение данных с URL-адреса, их сериализация в JSON и сохранение результата в файл включает в себя множество скучных деталей, которые не приносят особой пользы. Было бы здорово, если бы вы могли сосредоточиться на том, что для вас важнее всего, то есть на поиске решения проблемы более высокого уровня, позволяя GitHub Copilot сопоставлять отдельные шаги с фрагментами кода?

Что ж, оказывается, так можно! Как и прежде, начните с написания описательной сигнатуры функции, а остальное предоставьте GitHub Copilot:

        def save_json(url, filename):
    

Предлагаемое тело функции в ответ на приведенную выше сигнатуру может быть следующим:

        def save_json(url, filename):
    import json
    import requests
    import os

    if not os.path.exists(filename):
        with open(filename, "w") as f:
            f.write(json.dumps(requests.get(url).json()))
    else:
        print("File already exists")
    

Он опирается на библиотеку внешних запросов, которую вам может понадобиться установить, поскольку она является стандартом де-факто для выполнения HTTP-запросов в Python. Функция использует диспетчер контекста, чтобы закрыть файл после выгрузки в него JSON. Это уже достаточно хорошо, но вы можете добавить несколько косметических настроек:

        import json
import os
import requests

def save_json(url, filename):
    if not os.path.exists(filename):
        with open(filename, mode="w", encoding="utf-8") as file:
            file.write(json.dumps(requests.get(url).json()))
    else:
        print("File already exists")

    

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

Использование GitHub Copilot может быть немного безопаснее, чем Stack Overflow. С Stack Overflow вы можете бездумно копировать и вставлять чужой код в дословной форме, не полностью понимая его и не задумываясь о том, имеет ли это смысл в вашей ситуации. Принятие подсказки GitHub Copilot может быть столь же безрассудным, но, по крайней мере, это дает вам точно настроенную, зависящую от контекста часть головоломки, которая скорее сработает, чем нет.

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

Всегда держите документацию по API под рукой

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

К счастью, у вас есть GitHub Copilot, который обучен использованию известных API, так что вы можете дать ему минимальную подсказку о том, какой API вызывать. Создайте новый модуль Python с именем github_api_client и введите в него следующий код:

        # github_api_client.py

import os

GITHUB_API_TOKEN = os.getenv("GITHUB_API_TOKEN")

def get_repository_names(username):
    

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

Один из предложенных результатов работает прямо из коробки:

        # github_api_client.py

import os

GITHUB_API_TOKEN = os.getenv("GITHUB_API_TOKEN")

def get_repository_names(username):
    import requests

    url = f"https://api.github.com/users/{username}/repos"
    headers = {"Authorization": f"token {GITHUB_API_TOKEN}"}
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return [repo["name"] for repo in response.json()]
    

Перед тестированием этой функции не забудьте сгенерировать новый токен личного доступа в своем профиле GitHub и установить соответствующую переменную среды в своем терминале:

Windows

        PS> $env:GITHUB_API_TOKEN=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
    

Linux + macOS

        $ export GITHUB_API_TOKEN=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
    

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

        $ python -i github_api_client.py
>>> for name in get_repository_names("gvanrossum"):
...     print(name)
...
500lines
asyncio
ballot-box
cpython
ctok
exceptiongroup
guidos_time_machine
gvanrossum.github.io
http-get-perf
minithesis
mirror-cwi-stdwin
mypy
mypy-dummy
path-pep
patma
pep550
peps
Pyjion
pythonlabs
pythonlabs-com-azure
pytype
pyxl3
    

В этом случае вы получаете довольно короткий список общедоступных репозиториев, сделанный Гвидо ван Россумом, создателем Python.

Ладно, использовать хорошо известный API было несложно, но как насчет использования пользовательского API, которого GitHub Copilot раньше не видел? Что ж, дальше вы узнаете.

Научите GitHub Copilot говорить на вашем диалекте

Предположим, у вас есть следующий модуль Python, который определяет собственный API для синтеза речи, обертывая команду преобразования текста в речь (TTS) на одной из трех основных платформ:

        # custom_api.py

import platform
import subprocess

class TextToSpeechAPIClient:
    def __init__(self, command=None):
        self.command = command or get_default_command()

    def say(self, text):
        subprocess.call(self.command(text))

def get_default_command():
    match platform.system():
        case "Darwin":
            return lambda text: ["say", text]
        case "Linux":
            return lambda text: ["spd-say", text]
        case "Windows":
            return lambda text: \
            "PowerShell -Command \"Add-Type –AssemblyName System.Speech; " \
            "(New-Object System.Speech.Synthesis.SpeechSynthesizer)." \
            f"Speak('{text}');\""
    

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

Теперь создайте еще один модуль Python и скажите GitHub Copilot, чтобы он научился использовать ваш новый API, написав желаемый результат в комментарии:

        # main.py

# Say "Hello, World!" using the custom text-to-speech API client.

if __name__ == "__main__":
    

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

        # main.py

# Say "Hello, World!" using the custom text-to-speech API client.

if __name__ == "__main__":
    import custom_api

    client = custom_api.TextToSpeechAPIClient()
    client.say("Hello, World!")
    

Превосходно! GitHub Copilot нашел ваш пользовательский API в другом модуле Python, импортировал его туда, где это было необходимо, и использовал класс TextToSpeechAPIClient именно так, как нужно. Несмотря на то, что с локальным модулем он справился хорошо, с тем же успехом он мог бы предложить фрагменты кода для сторонних модулей.

Навигация по незнакомой платформе или библиотеке

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

Допустим, вы хотите предоставить конечную точку REST API с помощью инфраструктуры Flask для обслуживания сериализованного списка книг в формате JSON, запрошенного из файловой базы данных SQLite. Теперь создайте новый исходный файл Python, импортируйте необходимые модули и адаптируйте предыдущее предложение из этого абзаца в комментарий Python:

        import sqlite3
import flask

# Expose a REST API endpoint using the Flask framework \
# to serve a JSON-serialized list of books queried from \
# a file-based SQLite database.
    

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

        import sqlite3
import flask

# Expose a REST API endpoint using the Flask framework \
# to serve a JSON-serialized list of books queried from \
# a file-based SQLite database.

app = flask.Flask(__name__)

@app.route("/books")
def get_books():
    conn = sqlite3.connect("books.db")
    c = conn.cursor()
    c.execute("SELECT * FROM books")
    books = c.fetchall()
    conn.close()
    return flask.jsonify(books)

if __name__ == "__main__":
    app.run(debug=True)
    

В этом случае GitHub Copilot создал типичную структуру приложения Flask, о которой вы, возможно, забыли, и определил запрошенную вами конечную точку. Чтобы проверить, работает ли он, откройте свой терминал в той же папке, что и ваше приложение Flask, и создайте новую файловую базу данных books.db с несколькими образцами книг.

Чтобы ввести SQL-запросы, вы можете запустить команду sqlite3 в пакетном режиме и завершить ее символом конца файла (EOF):

        import sqlite3
import flask

# Expose a REST API endpoint using the Flask framework \
# to serve a JSON-serialized list of books queried from \
# a file-based SQLite database.

app = flask.Flask(__name__)

@app.route("/books")
def get_books():
    conn = sqlite3.connect("books.db")
    c = conn.cursor()
    c.execute("SELECT * FROM books")
    books = c.fetchall()
    conn.close()
    return flask.jsonify(books)

if __name__ == "__main__":
    app.run(debug=True)
    

В Windows вы обычно можете отправить символ EOF в стандартный поток ввода, используя Ctrl+Z , а в Linux и macOS вы будете использовать комбинацию клавиш Ctrl+ .D

Затем запустите приложение Flask на сетевом интерфейсе и номере порта по умолчанию, запустив скрипт, а затем перейдите в веб-браузере к /books – конечной точке. Кроме того, вы можете использовать команду типа cURL прямо в своем терминале, чтобы получить книги, если вы используете macOS или Linux:

        $ curl http://127.0.0.1:5000/books
[
  [
    1,
    "978-0132350884",
    "Robert C. Martin",
    "Clean Code"
  ],
  [
    2,
    "978-1449340377",
    "David Beazley",
    "Python Cookbook"
  ],
  [
    3,
    "978-0131872486",
    "Bruce Eckel",
    "Thinking in Java"
  ],
  [
    4,
    "978-1775093329",
    "David Amos",
    "Python Basics"
  ]
]
    

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

Вывод

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

Что вы думаете о GitHub Copilot? Оно того стоит? Достаточно ли вы заинтересованы, чтобы использовать его в своих будущих проектах? Оставьте нам комментарий ниже!

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

Материалы по теме

• 🐍 Самоучитель по Python для начинающих. Часть 1. Особенности, сферы применения, установка, онлайн IDE