Crea instrucciones para generar código

Los modelos gemini-1.0-pro y code-bison admiten la generación de código mediante una descripción en lenguaje natural. En este tema, se muestran las estrategias para crear mensajes que funcionen con los modelos compatibles a fin de generar código.

Casos de uso

Estos son algunos casos de uso comunes de generación de código:

  • Pruebas de unidades: Diseña un mensaje para solicitar una prueba de unidades para una función.

  • Escribir una función: Pasa un problema al modelo para obtener una función que lo resuelva.

  • Crear una clase: Usa una indicación para describir el propósito de una clase y tener un código que defina la clase que se muestra.

Modelos compatibles

Los siguientes modelos admiten tareas de generación de código:

  • gemini-1.0-pro
  • code-bison

Ejemplos de instrucciones de generación de código

Usa los siguientes ejemplos para aprender a diseñar instrucciones de generación de código.

Genera una secuencia de comandos de Docker

Puedes usar el modelo de generación de código para generar una secuencia de comandos de Docker. El siguiente mensaje genera una secuencia de comandos de Docker para crear una máquina Linux con bibliotecas específicas instaladas:


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.

Genera una función

Puedes usar el modelo de generación de código para generar una función. En el siguiente mensaje se genera una función que ingresa un año y determina si es un año bisiesto:


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
```

Genera una prueba de unidades

Puedes usar el modelo de generación de código para generar una prueba de unidades.

El siguiente mensaje genera una prueba de unidades para una función que determina si un año es bisiesto o no.


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()
```

¿Qué sigue?