Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Python exemples
Procédez comme suit : Python des exemples montrent comment vous pouvez commencer à générer des suggestions de code en ligne avec Amazon Q Developer. Ces exemples illustratifs vous montrent comment déclencher l'assistant de codage pour vos propres projets. La plupart des exemples suivants sont applicables à d'autres langues :
+ [Génération de classes et de fonctions](#classes-python)
+ [Code du document](#code-python)
+ [Générer des algorithmes](#algorithms-python)
+ [Générer des tests unitaires](#tests-python)
## Génération de classes et de fonctions
Pour générer une implémentation de classe complète ou partielle, utilisez des commentaires de code. Le commentaire décrit l'intention de la classe. Commencez simplement et ajoutez plus de détails si nécessaire. Après avoir généré une classe, vous pouvez continuer à générer des fonctions dans son squelette.
Lorsque vous rédigez des commentaires, il est préférable d'utiliser la structure de commentaires de la langue. Entrée Python, pour les commentaires d'une seule ligne, utilisez `#` ***.***Pour les commentaires multilignes, utilisez `''' '''` ou`""" """`.
Entrée :
```
'''
DocumentReader class. has a name, children and optional parent.
Includes I/O functions to read and
write document
'''
```
Sortie :
```
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
```
Maintenant qu'il existe une classe initiale, une fonction supplémentaire peut être générée avec des commentaires supplémentaires.
Entrée :
```
'''
function to read document from local directory path and print the first line of the document
'''
```
Sortie :
```
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}")
```
## Code du document
Réduisez le temps consacré à la documentation du code en vous appuyant sur la documentation en ligne. Addition Python pauses dans les commentaires`''' '''`.
Entrée :
```
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}")
```
Sortie :
```
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}")
```
## Générer des algorithmes
Amazon Q Developer peut générer des algorithmes populaires, en particulier ceux liés à AWS SDKs. Dans votre script, ajoutez une invite qui indique la fonction que vous souhaitez utiliser.
Cet exemple montre comment générer un dictionnaire de clés d'identification utilisateur pour nommer des valeurs, puis comment générer une fonction de tri à l'aide de l'algorithme de tri à bulles.
Entrée :
```
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
'''
```
Sortie :
```
@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)
```
En outre, vous pouvez créer des instructions pour les procédures standard. Dans cet exemple, l'utilisateur crée une invite pour stocker le dictionnaire dans une table Amazon DynamoDB. Au début du script, l'utilisateur ajoute une invite à ajouter des bibliothèques DynamoDB afin de fournir un contexte supplémentaire à Amazon Q Developer.
Entrée :
```
'''
Add libraries for Amazon Dynamo DB
'''
```
Sortie :
```
'''
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')
```
Désormais, l'utilisateur peut facilement demander à Amazon Q de l'aider à stocker le dictionnaire dans DynamoDB.
Entrée :
```
'''
function to store the above sorted dict to dynamodb table named users
'''
```
Sortie :
```
@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'])
```
## Générer des tests unitaires
Grâce aux commentaires intégrés, Amazon Q Developer peut générer des tests unitaires pour effectuer des assertions et d'autres tests. Dans cet exemple, l'utilisateur demande à Amazon Q de générer les bibliothèques applicables aux tests unitaires afin de définir le contexte du script de test. L'utilisateur demande ensuite à Amazon Q d'écrire une fonction de test pour cette `sort_user_id_name_map` fonction.
Entrée :
```
'''
Import all the required unit test libraries for python and then generate a unit test for sort_user_id_name_map function.
'''
```
Sortie :
```
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()
```
En outre, lors d'une discussion entre l'utilisateur et Amazon Q Developer, celui-ci suggère et génère des tests unitaires basés sur les instructions de saisie du code de l'utilisateur. Pour plus d'informations, consultez la section [Exemples de chat](examples-chat.md).