Kompletní kód a pomoc s procesem vývoje
Azure OpenAI může vývojářům pomoct při běžných úlohách vývoje softwaru, jako je psaní testů jednotek, dokončování částečného kódu, komentování kódu a generování dokumentace. Pomocí pomoci s AI můžou vývojáři trávit více času na složitém programování a řešení problémů.
Dokončení částečného kódu
Modely Azure OpenAI můžou generovat kód na základě komentářů, názvů funkcí a částečně napsaného kódu. Čím více kontextu můžete modelu poskytnout, tím přesnější je pravděpodobnost odpovědi.
Například při zadání následující výzvy:
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
Model vezme komentáře a začátek definice funkce a dokončí ho z libovolného kontextu, který má.
# 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;
}
}
V tomto případě bylo možné zjistit, co jsme chtěli kvůli relativně jednoduchému a úplnému komentáři před začátkem funkce. Při složitějších funkcích nebo úkolech je k získání užitečné odpovědi potřeba další kontext.
Je důležité si uvědomit, že u některých jazyků, jako je Python, je syntaxe dostatečně jasná, aby model mohl předpokládat, jaký jazyk je požadovaný. U syntakticky podobných jazyků, jako je C# nebo Java, existuje vyšší pravděpodobnost, že model používá nesprávný jazyk. V takovém případě zkuste zadat jazyk v příkazovém řádku nebo zadejte další kód pro kontext.
Podobné funkce lze vidět poskytnutím částečného kódu modelu bez jakýchkoli komentářů. Podívejte se například na následující výzvu.
complete the following code
"""
def func1(n)
if n==0:
complete the following code
"""
public int Func1(int n) {
if (n == 0) {
Model AI nejlépe dokončí funkci s nejpravděpodobnějším dokončením funkce.
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);
}
}
Odpověď pravděpodobně obsahuje také vysvětlení přirozeného jazyka, co tato funkce dělá. V tomto případě odpověděl rekurzivní implementací faktoriální funkce. Výzva však mohla být také začátkem fibonacciho funkce, která znázorňuje případ, kdy potřebujeme v výzvě více kontextu, abychom lépe označili to, co chceme z modelu.
Nástroje, jako je GitHub Copilot, využívají modely OpenAI k návrhu dokončování kódu a funkcí podobným způsobem jako u výše uvedených příkladů. GitHub Copilot je skvělým příkladem skutečného použití této funkce, která používá integrované výzvy a kontext kódu, který píšete, aby fungoval jako spárovaný programátor.
Zápis testů jednotek
Modely Azure OpenAI můžou generovat testy jednotek pro funkce, které napíšete, aby byl váš kód robustnější. Vezměte například funkci binárního vyhledávání.
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;
}
Zadejte tuto funkci spolu s výzvou write three unit tests for this functiona získáte odpověď podobnou následující.
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);
}
Tato funkce je ještě užitečnější, pokud zadáte případy, které chcete zahrnout do výzvy, což zkracuje dobu potřebnou k psaní testů jednotek pro váš kód.
Přidání komentářů a generování dokumentace
Pro další vylepšení kódu můžou modely AI přidávat komentáře a dokumentaci za vás. Jako příklad použijte následující funkci, která může být při prvním čtení bez komentářů ke kódu trochu obtížná.
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;
}
}
Poskytněte této funkci modelu spolu s výzvou, že do kódu přidá komentáře, a dostanete odpověď podobnou následující.
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;
}
}
Proveďte krok dále a požádejte o dokumentaci k funkci, do které právě přidal komentáře.
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;
}
}