Prompts zum Generieren von Code erstellen

In diesem Dokument werden Strategien zum Erstellen von Prompts beschrieben, die mit den unterstützten Modellen arbeiten, um Code anhand einer Beschreibung in natürlicher Sprache zu generieren.

Anwendungsfälle

Typische Anwendungsfälle für das Generieren von Code sind:

  • Unittests: Verwenden Sie die Eingabeaufforderung, um einen Unittest für eine Funktion anzufordern.

  • Funktion schreiben: Übergeben Sie ein Problem an das Modell, um eine Funktion zu erhalten, die dieses Problem löst.

  • Klasse erstellen: Verwenden Sie einen Prompt, um den Zweck einer Klasse zu beschreiben und Code zur Definition der Klasse zu erhalten.

Unterstützte Modelle

Die folgenden Modelle unterstützen Code-Generierungs-Aufgaben:

  • Gemini 1.5 Flash
  • Gemini 1.5 Pro,
  • Gemini 1.0 Pro

Beispiele: Prompts zur Codegenerierung

In den folgenden Beispielen wird gezeigt, wie Sie Prompts zur Codegenerierung erstellen.

Docker-Script generieren

Sie können das Modell zur Codegenerierung verwenden, um ein Docker-Skript zu generieren. Mit folgendem Prompt wird ein Docker-Skript generiert, um einen Linux-Rechner mit bestimmten installierten Bibliotheken zu erstellen:

Generate a Docker script to create a simple linux machine that has python 3.10 installed with following libraries: pandas, tensorflow, numpy
  
```
# Create a new Dockerfile
FROM ubuntu:20.04

# Update the package list
RUN apt-get update

# Install Python 3.10
RUN apt-get install -y python3.10

# Install Python libraries
RUN pip install pandas tensorflow numpy

# Create a new user
RUN useradd -m user

# Set the default user
USER user

# Start the Python shell
CMD ["python"]
```

To build the Docker image, run the following command:

```
docker build -t my-python-image .
```

To run the Docker image, run the following command:

```
docker run -it --rm my-python-image
```

This starts a new container based on the `my-python-image` image. You can then use the Python shell to interact with the container. For example, you can install additional Python libraries or run Python scripts.

Funktion generieren

Mit dem Modell zur Codegenerierung können Sie eine Funktion generieren. Der folgende Prompt generiert eine Funktion, die ein Jahr eingibt und bestimmt, ob es ein Schaltjahr ist oder nicht:

Write a function that checks if a year is a leap year.
  
```python
def is_leap_year(year):
"""
def is_leap_year(year):
  """
  Check if a year is a leap year.

  Args:
    year: The year to check.

  Returns:
    True if the year is a leap year, False otherwise.
  """

  if year % 4 != 0:
    return False
  elif year % 100 == 0 and year % 400 != 0:
    return False
  else:
    return True
```

Unittest generieren

Sie können das Modell zur Codegenerierung verwenden, um einen Unittest zu erstellen.

Der folgende Prompt generiert einen Unitest für eine Funktion, die bestimmt, ob ein Jahr ein Schaltjahr ist.

Write a unit test for this function:
def is_leap_year(year):
  """
  Check if a year is a leap year.

  Args:
    year: The year to check.

  Returns:
    True if the year is a leap year, False otherwise.
  """

  if year % 4 != 0:
    return False
  elif year % 100 == 0 and year % 400 != 0:
    return False
  else:
    return True
  
```python
import unittest

class IsLeapYearTest(unittest.TestCase):

    def test_is_leap_year_true(self):
        self.assertTrue(is_leap_year(2000))
        self.assertTrue(is_leap_year(2004))
        self.assertTrue(is_leap_year(2012))

    def test_is_leap_year_false(self):
        self.assertFalse(is_leap_year(1900))
        self.assertFalse(is_leap_year(1999))
        self.assertFalse(is_leap_year(2100))

    def test_is_leap_year_invalid_input(self):
        with self.assertRaises(TypeError):
            is_leap_year("2000")

if __name__ == '__main__':
    unittest.main()
```

Nächste Schritte