As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Python exemplos
Os seguintes exemplos de Python exemplos demonstram como você pode começar a gerar sugestões de código em linha com o Amazon Q Developer. Esses exemplos ilustrativos mostram como acionar o assistente de codificação para seus próprios projetos. A maioria dos exemplos a seguir se aplica a outros idiomas:
+ [Gere classes e funções](#classes-python)
+ [Código do documento](#code-python)
+ [Gere algoritmos](#algorithms-python)
+ [Gere testes unitários](#tests-python)
## Gere classes e funções
Para gerar a implementação total ou parcial da classe, use comentários de código. O comentário descreve a intenção da turma. Comece de forma simples e adicione mais detalhes, se necessário. Depois de gerar uma classe, você pode continuar gerando funções dentro de seu esqueleto.
Ao escrever comentários, é preferível usar a estrutura de comentários do idioma. Em Python, para comentários de linha única, use `#` ***.***Para comentários de várias linhas, use `''' '''` ou`""" """`.
Entrada:
```
'''
DocumentReader class. has a name, children and optional parent.
Includes I/O functions to read and
write document
'''
```
Saída:
```
class DocumentReader:
def __init__(self, name, children, parent=None):
self.name = name
self.parent = parent
self.children = children
def read(self):
"""Reads current document and returns text"""
pass
def write(self, text):
"""Writes text to current document"""
pass
```
Agora que há uma classe inicial, uma função adicional pode ser gerada com comentários adicionais.
Entrada:
```
'''
function to read document from local directory path and print the first line of the document
'''
```
Saída:
```
def read_document(self, path):
"""Reads document from path and prints first line"""
import os
if os.path.isfile(path):
with open(path, 'r') as f:
print(f.readline())
else:
print(f"File not found at {path}")
```
## Código do documento
Reduza o tempo na documentação do código confiando na documentação em linha. Adicionar Python pausas para comentários`''' '''`.
Entrada:
```
class S3Utils:
'''
'''
def __init__(self):
self.base_url = "https://s3"
def generate_s3_url(self, bucket_name, region):
return f"{self.base_url}.{region}.amazonaws.com/{bucket_name}"
# Example usage:
if __name__ == "__main__":
s3_util = S3Utils()
bucket_name = "my-example-bucket"
region = "us-west-1"
s3_url = s3_util.generate_s3_url(bucket_name, region)
print(f"S3 URL for bucket '{bucket_name}' in region '{region}': {s3_url}")
```
Saída:
```
class S3Utils:
'''
Class to generate S3 URL from bucket name and region
'''
def __init__(self):
self.base_url = "https://s3"
def generate_s3_url(self, bucket_name, region):
return f"{self.base_url}.{region}.amazonaws.com/{bucket_name}"
# Example usage:
if __name__ == "__main__":
s3_util = S3Utils()
bucket_name = "my-example-bucket"
region = "us-west-1"
s3_url = s3_util.generate_s3_url(bucket_name, region)
print(f"S3 URL for bucket '{bucket_name}' in region '{region}': {s3_url}")
```
## Gere algoritmos
O Amazon Q Developer pode gerar algoritmos populares, especialmente relacionados AWS SDKs a. Em seu script, adicione um prompt que especifique a função que você deseja.
Este exemplo mostra como gerar um dicionário de chaves de identificação de usuário para nomear valores e, em seguida, gerar uma função de classificação usando o algoritmo de classificação por bolhas.
Entrada:
```
class SortList:
@staticmethod
def get_user_id_name_map():
user_id_name_map = {
1: "Amit",
2: "Rahul",
3: "Vijay",
4: "Raj",
5: "Kumar"
}
return user_id_name_map
'''
Sort the list of user id's alphabetically using bubble sort
'''
```
Saída:
```
@staticmethod
def sort_user_id_name_map():
user_id_name_map = SortList.get_user_id_name_map()
list_of_user_ids = list(user_id_name_map.keys())
list_of_user_names = list(user_id_name_map.values())
print("Before sort: ", list_of_user_ids)
for i in range(len(list_of_user_ids)):
for j in range(len(list_of_user_ids) - i - 1):
if list_of_user_names[j] > list_of_user_names[j + 1]:
list_of_user_ids[j], list_of_user_ids[j + 1] = list_of_user_ids[j + 1], list_of_user_ids[j]
list_of_user_names[j], list_of_user_names[j + 1] = list_of_user_names[j + 1], list_of_user_names[j]
print("After sort: ", list_of_user_ids)
```
Além disso, você pode criar solicitações para procedimentos padrão. Neste exemplo, o usuário cria um prompt para armazenar o dicionário em uma tabela do Amazon DynamoDB. No início do script, o usuário adiciona uma solicitação para adicionar bibliotecas do DynamoDB para ajudar a fornecer contexto adicional ao Amazon Q Developer.
Entrada:
```
'''
Add libraries for Amazon Dynamo DB
'''
```
Saída:
```
'''
Add libraries for Amazon Dynamo DB and JSON.
iMport necessary libraries for working with Amazon DynamoDB and JSON data.
'''
import boto3
import json
from botocore.exceptions import ClientError
def load_data_to_dynamodb(table_name, data_file):
# Create a DynamoDB resource
dynamodb = boto3.resource('dynamodb')
# Get a reference to the table
table = dynamodb.Table(table_name)
# Load data from the JSON file
with open(data_file, 'r') as file:
data = json.load(file)
# Iterate over the data and load it to the table
for item in data:
try:
table.put_item(Item=item)
print(f"Successfully loaded data: {item}")
except ClientError as e:
print(f"Error loading data: {e.response['Error']['Message']}")
# Example usage
load_data_to_dynamodb('myTable', 'data.json')
```
Agora, o usuário pode facilmente pedir ajuda ao Amazon Q para armazenar o dicionário no DynamoDB.
Entrada:
```
'''
function to store the above sorted dict to dynamodb table named users
'''
```
Saída:
```
@staticmethod
def store_user_id_name_map_in_dynamodb():
user_id_name_map = SortList.get_user_id_name_map()
list_of_user_ids = list(user_id_name_map.keys())
list_of_user_names = list(user_id_name_map.values())
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('users')
for i in range(len(list_of_user_ids)):
try:
response = table.put_item(
Item={
'user_id': list_of_user_ids[i],
'user_name': list_of_user_names[i]
}
)
except ClientError as e:
print(e.response['Error']['Message'])
```
## Gere testes unitários
Com comentários em linha, o Amazon Q Developer pode gerar testes unitários para realizar afirmações e outros testes. Neste exemplo, o usuário solicita à Amazon Q que gere bibliotecas aplicáveis para testes unitários para definir o contexto do script de teste. Em seguida, o usuário solicita à Amazon Q que escreva uma função de teste para a `sort_user_id_name_map` função.
Entrada:
```
'''
Import all the required unit test libraries for python and then generate a unit test for sort_user_id_name_map function.
'''
```
Saída:
```
import unittest
from unittest.mock import patch
from sort_user_id_name_map import sort_user_id_name_map
class TestSortUserIdNameMap(unittest.TestCase):
@patch('sort_user_id_name_map.sort_user_id_name_map')
def test_sort_user_id_name_map(self, mock_sort):
mock_sort.return_value = {'id1': 'name1', 'id2': 'name2'}
result = sort_user_id_name_map({'id2': 'name2', 'id1': 'name1'})
self.assertEqual(result, {'id1': 'name1', 'id2': 'name2'})
if __name__ == '__main__':
unittest.main()
```
Além disso, em um bate-papo entre o usuário e o Amazon Q Developer, ele sugere e gera testes unitários com base nos prompts de entrada de código do usuário. Para obter mais informações, consulte [Exemplos de bate-papo](examples-chat.md).