Ukończ kod i wspomagaj proces programowania
Usługa Azure OpenAI może pomóc deweloperom w typowych zadaniach tworzenia oprogramowania, takich jak pisanie testów jednostkowych, kończenie częściowego kodu, komentowanie kodu i generowanie dokumentacji. Użycie pomocy w zakresie sztucznej inteligencji może umożliwić deweloperom poświęcanie większego czasu na złożone zadania programistyczne i rozwiązywanie problemów.
Ukończ częściowy kod
Modele usługi Azure OpenAI mogą generować kod na podstawie komentarzy, nazw funkcji i częściowo napisanego kodu. Tym więcej kontekstu można podać model, tym bardziej dokładna jest odpowiedź najprawdopodobniej.
Na przykład po wyświetleniu następującego monitu:
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 pobiera komentarze i rozpoczyna definicję funkcji i wypełnia ją z dowolnego kontekstu, który ma.
# 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;
}
}
W tym przypadku był w stanie rozpoznać to, czego chcieliśmy ze względu na stosunkowo prosty i kompletny komentarz poprzedzający rozpoczęcie funkcji. W przypadku bardziej złożonych funkcji lub zadań wymagana jest większa liczba kontekstów w celu uzyskania przydatnej odpowiedzi.
Należy pamiętać, że w przypadku niektórych języków, takich jak Python, składnia jest wystarczająco jasna, aby model zakładał, jaki język jest wymagany. W przypadku języków syntaktycznie podobnych, takich jak C# lub Java, istnieje większe prawdopodobieństwo, że model używa niewłaściwego języka. Jeśli tak jest, spróbuj określić język w wierszu polecenia lub podać więcej kodu dla kontekstu.
Podobne funkcje można zobaczyć, dostarczając częściowy kod do modelu bez żadnych komentarzy. Skorzystaj z następującego monitu, aby na przykład.
complete the following code
"""
def func1(n)
if n==0:
complete the following code
"""
public int Func1(int n) {
if (n == 0) {
Model sztucznej inteligencji robi wszystko, co w jego mocy, aby ukończyć funkcję z najbardziej prawdopodobnym ukończeniem funkcji.
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);
}
}
Odpowiedź prawdopodobnie zawiera również wyjaśnienie języka naturalnego, co robi ta funkcja. W tym przypadku odpowiedziała rekursywną implementacją funkcji czynnikowej. Jednak monit mógł być również początkiem funkcji Fibonacciego, która ilustruje przypadek, w którym potrzebujemy więcej kontekstu w wierszu polecenia, aby lepiej wskazać, czego chcemy z modelu.
Narzędzia, takie jak GitHub Copilot, wykorzystują modele OpenAI do sugerowania kodu i uzupełniania funkcji w podobny sposób do powyższych przykładów. GitHub Copilot to doskonały przykład rzeczywistego użycia tej funkcji, która używa wbudowanych monitów i kontekstu kodu, który piszesz do działania jako sparowany programista.
Pisanie testów jednostkowych
Modele usługi Azure OpenAI mogą generować testy jednostkowe dla pisanych funkcji, aby ułatwić zwiększenie niezawodności kodu. Weźmy na przykład funkcję wyszukiwania binarnego.
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;
}
Podaj tę funkcję wraz z monitem write three unit tests for this functioni otrzymasz odpowiedź podobną do poniższej.
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);
}
Ta funkcja jest jeszcze bardziej przydatna, jeśli określisz przypadki, które mają zostać uwzględnione w wierszu polecenia, co skraca czas potrzebny na pisanie testów jednostkowych dla kodu.
Dodawanie komentarzy i generowanie dokumentacji
Aby jeszcze bardziej ulepszyć kod, modele sztucznej inteligencji mogą dodawać komentarze i dokumentację. Weź pod uwagę następującą funkcję jako przykład, co może być nieco trudne do zrozumienia podczas pierwszego czytania go bez żadnych komentarzy kodu.
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;
}
}
Podaj tę funkcję w modelu wraz z monitem z żądaniem dodania komentarzy do kodu i otrzymasz odpowiedź podobną do poniższej.
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;
}
}
Wykonaj krok dalej i poproś o dokumentację funkcji, do której właśnie dodano komentarze.
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;
}
}