Completar código y ayudar en el proceso de desarrollo
Azure OpenAI puede ayudar a los desarrolladores en tareas comunes de desarrollo de software, como escribir pruebas unitarias, completar código parcial, comentar código y generar documentación. El uso de la ayuda de inteligencia artificial puede permitir a los desarrolladores dedicar más tiempo a tareas complejas de programación y de resolución de problemas.
Completar código parcial
Los modelos de Azure OpenAI pueden generar código en función de comentarios, nombres de función y código escrito parcialmente. Cuanto más contexto pueda proporcionar al modelo, probablemente más precisa será la respuesta.
Por ejemplo, cuando se da el mensaje siguiente:
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
El modelo toma los comentarios y el inicio de la definición de función y lo completa desde cualquier contexto que tenga.
# 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;
}
}
En este caso, ha podido distinguir lo que queríamos debido a un comentario relativamente sencillo y completo que precede al inicio de la función. Con funciones o tareas más complejas, se requiere más contexto para obtener una respuesta útil.
Es importante tener en cuenta que para algunos lenguajes, como Python, la sintaxis es lo suficientemente clara para que el modelo asuma qué lenguaje se quiere usar. En lenguajes de sintaxis similar, como C# o Java, es más probable que el modelo use el lenguaje incorrecto. Si este es el caso, intente especificar el lenguaje en el mensaje o proporcione más código para el contexto.
El funcionamiento es similar al proporcionar código parcial al modelo, sin comentarios. Tome el mensaje siguiente, por ejemplo.
complete the following code
"""
def func1(n)
if n==0:
complete the following code
"""
public int Func1(int n) {
if (n == 0) {
El modelo de IA hace todo lo posible por completar la función con la finalización más probable de la función.
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 respuesta también puede incluir una explicación en lenguaje natural de lo que hace esa función. En este caso, respondió con una implementación recursiva de la función factorial. Sin embargo, el mensaje también podría haber sido el inicio de una función de Fibonacci, que ilustra un caso en el que se necesita más contexto en el mensaje para indicar mejor qué queremos del modelo.
Herramientas como GitHub Copilot usan modelos de OpenAI para sugerir finalizaciones de código y de función de forma similar a los ejemplos anteriores. GitHub Copilot es un excelente ejemplo de uso real de esta funcionalidad que utiliza mensajes integrados y el contexto del código en el que está escribiendo actúa como programador emparejado.
Escribir pruebas unitarias
Los modelos de Azure OpenAI pueden generar pruebas unitarias para las funciones que escribe a fin de ayudarle a que el código sea más sólido. Tome como ejemplo la función de búsqueda binaria.
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;
}
Proporcione esa función junto con el mensaje write three unit tests for this function y obtendrá una respuesta similar a la siguiente.
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);
}
Esta funcionalidad es aún más útil si especifica los casos que quiere incluir en el mensaje, lo que reduce el tiempo que tarda en escribir pruebas unitarias para el código.
Adición de comentarios y generación de documentación
Para mejorar aún más el código, los modelos de IA pueden agregar comentarios y documentación. Tome la función siguiente como ejemplo, aunque puede ser un poco difícil entenderla al leer por primera vez sin ningún comentario de código.
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;
}
}
Proporcione esa función al modelo, junto con un mensaje en el que se solicite que agregue comentarios al código, y obtendrá una respuesta similar a la siguiente.
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;
}
}
Vaya un paso más allá y solicite documentación para la función a la que se acaban de agregar comentarios.
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;
}
}