Compléter du code et faciliter le processus de développement
Azure OpenAI peut aider les développeurs à effectuer des tâches courantes de développement de logiciels, comme écrire des tests unitaires, compléter du code partiel, commenter du code et générer la documentation. Le recours à l’IA permet aux développeurs de consacrer plus de temps aux tâches de programmation complexe et de résolution des problèmes.
Compléter du code partiel
Les modèles Azure OpenAI sont capables de générer du code en fonction de commentaires, de noms de fonctions et de code partiellement écrit. Plus vous pouvez fournir du contexte au modèle, plus la réponse a des chances d’être précise.
Par exemple, à l’invite suivante :
complete the following function
"""
# calculate the average of the numbers in an array, but only if they're even
def
complete the following function
"""
// calculate the average of the numbers in an array, but only if they're even
public
Le modèle prend les commentaires et le début de la définition de fonction, puis il la complète à partir du contexte dont il dispose.
# calculate the average of the even numbers in an array
def calculate_even_average(numbers):
total = 0
count = 0
for number in numbers:
if number % 2 == 0:
total += number
count += 1
if count == 0:
return 0 # avoid division by zero
else:
return total / count
// calculate the average of the even numbers in an array
public double CalculateEvenAverage(int[] numbers) {
int total = 0;
int count = 0;
foreach (int number in numbers) {
if (number % 2 == 0) {
total += number;
count++;
}
}
if (count == 0) {
return 0; // avoid division by zero
} else {
return (double) total / count;
}
}
Dans cet exemple, il a pu discerner ce que nous voulions grâce à un commentaire relativement simple et complet précédant le début de la fonction. Avec des fonctions ou tâches plus complexes, davantage de contexte est nécessaire pour obtenir une réponse utile.
Il est important de noter que pour certains langages, comme Python, la syntaxe est suffisamment claire pour que le modèle en déduise le langage souhaité. Pour les langages syntaxiquement similaires comme C# ou Java, le risque que le modèle utilise le mauvais langage est plus élevé. Dans ce cas, essayez de spécifier le langage dans l’invite ou de fournir plus de code pour le contexte.
Un fonctionnement similaire peut être observé en fournissant du code partiel au modèle, sans aucun commentaire. Prenez l’invite suivante à titre d’exemple.
complete the following code
"""
def func1(n)
if n==0:
complete the following code
"""
public int Func1(int n) {
if (n == 0) {
Le modèle IA fait de son mieux pour compléter la fonction avec la complétion la plus probable de la fonction.
def func1(n):
if n == 0:
return 1
else:
return n * func1(n-1)
public int Func1(int n) {
if (n == 0) {
return 1;
} else {
return n * Func1(n-1);
}
}
La réponse inclut probablement aussi une explication en langage naturel de ce que cette fonction effectue. Dans cet exemple, elle a répondu par une implémentation récursive de la fonction factorielle. Néanmoins, l’invite aurait également pu correspondre au début d’une fonction Fibonacci, ce qui illustre un cas où nous avons besoin de plus de contexte dans l’invite pour mieux indiquer ce que nous attendons du modèle.
Des outils comme GitHub Copilot utilisent des modèles OpenAI pour suggérer des complétions de code et de fonction de la même manière que dans les exemples ci-dessus. GitHub Copilot est un excellent exemple d’utilisation réelle de cette fonctionnalité qui recourt à des invites intégrées et au contexte du code que vous écrivez pour jouer le rôle de votre programmeur associé.
Écrire des tests unitaires
Les modèles Azure OpenAI peuvent générer des tests unitaires pour les fonctions que vous écrivez afin de rendre votre code plus robuste. Prenons par exemple la fonction de recherche binaire.
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
public static int BinarySearch(int[] arr, int target)
{
int left = 0;
int right = arr.Length - 1;
while (left <= right)
{
int mid = (left + right) / 2;
if (arr[mid] == target)
{
return mid;
}
else if (arr[mid] < target)
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}
Fournissez cette fonction avec l’invite write three unit tests for this function et vous obtenez une réponse similaire à la suivante.
def test_binary_search():
# Test case 1: Target element is in the middle of the array
arr1 = [1, 2, 3, 4, 5, 6]
target1 = 4
assert binary_search(arr1, target1) == 3
# Test case 2: Target element is at the beginning of the array
arr2 = [1, 2, 3, 4, 5, 6]
target2 = 1
assert binary_search(arr2, target2) == 0
# Test case 3: Target element is not in the array
arr3 = [1, 2, 3, 4, 5, 6]
target3 = 7
assert binary_search(arr3, target3) == -1
[Test]
public void TestBinarySearch1()
{
int[] arr = { 1, 2, 3, 4, 5 };
int target = 3;
int expected = 2;
int result = BinarySearch(arr, target);
Assert.AreEqual(expected, result);
}
[Test]
public void TestBinarySearch2()
{
int[] arr = { 10, 20, 30, 40, 50 };
int target = 35;
int expected = -1;
int result = BinarySearch(arr, target);
Assert.AreEqual(expected, result);
}
[Test]
public void TestBinarySearch3()
{
int[] arr = { 3, 6, 9, 12, 15 };
int target = 6;
int expected = 1;
int result = BinarySearch(arr, target);
Assert.AreEqual(expected, result);
}
Cette fonctionnalité s’avère encore plus utile si vous spécifiez les cas à inclure dans votre invite, ce qui réduit le temps nécessaire pour écrire des tests unitaires pour votre code.
Ajouter des commentaires et générer la documentation
Pour améliorer encore votre code, les modèles IA peuvent ajouter automatiquement des commentaires et la documentation. Prenons la fonction suivante à titre d’exemple, laquelle peut s’avérer un peu difficile à comprendre à sa première lecture en l’absence de commentaires de code.
def permutations(lst):
if len(lst) == 0:
return []
elif len(lst) == 1:
return [lst]
else:
result = []
for i in range(len(lst)):
temp = lst[i]
remaining = lst[:i] + lst[i+1:]
for p in permutations(remaining):
result.append([temp] + p)
return result
public static List<List<int>> Permutations(List<int> lst)
{
if (lst.Count == 0)
{
return new List<List<int>>();
}
else if (lst.Count == 1)
{
return new List<List<int>> { lst };
}
else
{
List<List<int>> result = new List<List<int>>();
for (int i = 0; i < lst.Count; i++)
{
int temp = lst[i];
List<int> remaining = new List<int>(lst);
remaining.RemoveAt(i);
foreach (List<int> p in Permutations(remaining))
{
List<int> permutation = new List<int> { temp };
permutation.AddRange(p);
result.Add(permutation);
}
}
return result;
}
}
Fournissez cette fonction au modèle, de concert avec une invite lui demandant d’ajouter des commentaires au code. Vous obtenez alors une réponse similaire à la suivante.
def permutations(lst):
# Check if the input list is empty
if len(lst) == 0:
return []
# Check if the input list has only one element
elif len(lst) == 1:
return [lst]
else:
# Initialize an empty list to store permutations
result = []
# Iterate through each element of the input list
for i in range(len(lst)):
# Remove the current element from the list and store it in a variable
temp = lst[i]
remaining = lst[:i] + lst[i+1:]
# Recursively call the function on the remaining list
for p in permutations(remaining):
# Append the current element to the beginning of each permutation and add it to the result list
result.append([temp] + p)
# Return the final list of permutations
return result
public static List<List<int>> Permutations(List<int> lst)
{
// Check if the input list is empty
if (lst.Count == 0)
{
return new List<List<int>>();
}
// Check if the input list has only one element
else if (lst.Count == 1)
{
return new List<List<int>> { lst };
}
else
{
// Initialize an empty list to store permutations
List<List<int>> result = new List<List<int>>();
// Iterate through each element of the input list
for (int i = 0; i < lst.Count; i++)
{
// Remove the current element from the list and store it in a variable
int temp = lst[i];
List<int> remaining = new List<int>(lst);
remaining.RemoveAt(i);
// Recursively call the function on the remaining list
foreach (List<int> p in Permutations(remaining))
{
// Append the current element to the beginning of each permutation and add it to the result list
List<int> permutation = new List<int> { temp };
permutation.AddRange(p);
result.Add(permutation);
}
}
// Return the final list of permutations
return result;
}
}
Allez encore plus loin en lui demandant la documentation de la fonction à laquelle il vient d’ajouter des commentaires.
def permutations(lst):
"""
Generates all possible permutations of a given list of integers using recursion.
Args:
lst (list): The list of integers to generate permutations for.
Returns:
list: A list of all possible permutations of the input list.
"""
# Check if the input list is empty
if len(lst) == 0:
return []
# Check if the input list has only one element
elif len(lst) == 1:
return [lst]
else:
# Initialize an empty list to store permutations
result = []
# Iterate through each element of the input list
for i in range(len(lst)):
# Remove the current element from the list and store it in a variable
temp = lst[i]
remaining = lst[:i] + lst[i+1:]
# Recursively call the function on the remaining list
for p in permutations(remaining):
# Append the current element to the beginning of each permutation and add it to the result list
result.append([temp] + p)
# Return the final list of permutations
return result
/// <summary>
/// Generates all possible permutations of a given list of integers using recursion.
/// </summary>
/// <param name="lst">The list of integers to generate permutations for.</param>
/// <returns>A list of all possible permutations of the input list.</returns> ```
public static List<List<int>> Permutations(List<int> lst)
{
// Check if the input list is empty
if (lst.Count == 0)
{
return new List<List<int>>();
}
// Check if the input list has only one element
else if (lst.Count == 1)
{
return new List<List<int>> { lst };
}
else
{
// Initialize an empty list to store permutations
List<List<int>> result = new List<List<int>>();
// Iterate through each element of the input list
for (int i = 0; i < lst.Count; i++)
{
// Remove the current element from the list and store it in a variable
int temp = lst[i];
List<int> remaining = new List<int>(lst);
remaining.RemoveAt(i);
// Recursively call the function on the remaining list
foreach (List<int> p in Permutations(remaining))
{
// Append the current element to the beginning of each permutation and add it to the result list
List<int> permutation = new List<int> { temp };
permutation.AddRange(p);
result.Add(permutation);
}
}
// Return the final list of permutations
return result;
}
}