Code voltooien en het ontwikkelingsproces ondersteunen
Azure OpenAI kan ontwikkelaars helpen bij algemene softwareontwikkelingstaken, zoals het schrijven van eenheidstests, het voltooien van gedeeltelijke code, het toevoegen van commentaarcode en het genereren van documentatie. Door AI-hulp te gebruiken, kunnen ontwikkelaars meer tijd besteden aan complexe programmeer- en probleemoplossingstaken.
Gedeeltelijke code voltooien
Azure OpenAI-modellen kunnen code genereren op basis van opmerkingen, functienamen en gedeeltelijk geschreven code. Hoe meer context u het model kunt bieden, hoe nauwkeuriger het antwoord waarschijnlijk is.
Wanneer u bijvoorbeeld de volgende prompt krijgt:
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
Het model neemt de opmerkingen en het begin van de functiedefinitie en voltooit het vanuit de context die het heeft.
# 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;
}
}
In dit geval kon het zien wat we wilden vanwege een relatief eenvoudige en volledige opmerking voorafgaand aan het begin van de functie. Bij complexere functies of taken is meer context vereist om een nuttig antwoord te krijgen.
Het is belangrijk om te weten dat voor sommige talen, zoals Python, de syntaxis duidelijk genoeg is om ervan uit te gaan welke taal moet worden gebruikt. Voor syntactisch vergelijkbare talen, zoals C# of Java, is de kans groter dat het model de verkeerde taal gebruikt. Als dat het geval is, geeft u de taal op in de prompt of geeft u meer code op voor context.
Vergelijkbare functionaliteit kan worden gezien door gedeeltelijke code aan het model te verstrekken, zonder opmerkingen. Neem bijvoorbeeld de volgende prompt.
complete the following code
"""
def func1(n)
if n==0:
complete the following code
"""
public int Func1(int n) {
if (n == 0) {
Het AI-model doet het beste om de functie te voltooien met de meest waarschijnlijke voltooiing van de functie.
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);
}
}
Het antwoord bevat waarschijnlijk ook een uitleg in natuurlijke taal van wat die functie doet. In dit geval reageerde het met een recursieve implementatie van de factoriële functie. De prompt kan echter ook het begin zijn geweest van een Fibonacci-functie, wat een geval illustreert waarin we meer context nodig hebben in de prompt om beter aan te geven wat we van het model willen.
Hulpprogramma's zoals GitHub Copilot maken gebruik van OpenAI-modellen om code- en functievoltooiingen op een vergelijkbare manier voor te stellen als in de bovenstaande voorbeelden. GitHub Copilot is een uitstekend voorbeeld van het echte gebruik van deze functionaliteit die gebruikmaakt van ingebouwde prompts en de context van de code die u schrijft om te fungeren als uw gekoppelde programmeur.
Eenheidstests schrijven
Azure OpenAI-modellen kunnen eenheidstests genereren voor functies die u schrijft om uw code robuuster te maken. Neem bijvoorbeeld de binaire zoekfunctie.
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;
}
Geef deze functie op samen met de prompt write three unit tests for this functionen u krijgt een antwoord dat lijkt op het volgende.
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);
}
Deze functionaliteit is nog nuttiger als u de aanvragen opgeeft die u wilt opnemen in uw prompt, waardoor u minder tijd nodig hebt om eenheidstests voor uw code te schrijven.
Opmerkingen toevoegen en documentatie genereren
Om uw code verder te verbeteren, kunnen AI-modellen opmerkingen en documentatie voor u toevoegen. Neem de volgende functie als voorbeeld. Dit kan een beetje moeilijk te begrijpen zijn wanneer u deze voor het eerst leest zonder codeopmerkingen.
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;
}
}
Geef die functie op voor het model, samen met een prompt waarin wordt gevraagd om opmerkingen toe te voegen aan de code en u krijgt een antwoord dat lijkt op het volgende.
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;
}
}
Ga nog een stap verder en vraag documentatie aan voor de functie waaraan deze zojuist opmerkingen heeft toegevoegd.
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;
}
}