Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Python Beispiele
Folgendes Python Beispiele zeigen, wie Sie mit der Generierung von Inline-Codevorschlägen mit Amazon Q Developer beginnen können. Diese anschaulichen Beispiele zeigen Ihnen, wie Sie den Codierungsassistenten für Ihre eigenen Projekte auslösen können. Ein Großteil der folgenden Beispiele ist auf andere Sprachen anwendbar:
+ [Generieren Sie Klassen und Funktionen](#classes-python)
+ [Code des Dokuments](#code-python)
+ [Generieren Sie Algorithmen](#algorithms-python)
+ [Generieren Sie Komponententests](#tests-python)
## Generieren Sie Klassen und Funktionen
Verwenden Sie Codekommentare, um eine vollständige oder teilweise Klassenimplementierung zu generieren. Der Kommentar beschreibt die Absicht der Klasse. Fangen Sie einfach an und fügen Sie bei Bedarf weitere Details hinzu. Nachdem Sie eine Klasse generiert haben, können Sie mit der Generierung von Funktionen innerhalb ihres Skeletts fortfahren.
Wenn Sie Kommentare schreiben, ist es vorzuziehen, die Kommentarstruktur der Sprache zu verwenden. In Python, für einzeilige Kommentare, verwenden Sie `#` ***.***Verwenden Sie für mehrzeilige Kommentare `''' '''` oder`""" """`.
Eingabe:
```
'''
DocumentReader class. has a name, children and optional parent.
Includes I/O functions to read and
write document
'''
```
Ausgabe:
```
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
```
Da es nun eine erste Klasse gibt, kann eine zusätzliche Funktion mit zusätzlichen Kommentaren generiert werden.
Eingabe:
```
'''
function to read document from local directory path and print the first line of the document
'''
```
Ausgabe:
```
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 des Dokuments
Reduzieren Sie den Zeitaufwand für die Codedokumentation, indem Sie sich auf die Inline-Dokumentation verlassen. Addition Python Kommentarunterbrechungen`''' '''`.
Eingabe:
```
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}")
```
Ausgabe:
```
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}")
```
## Generieren Sie Algorithmen
Amazon Q Developer kann beliebte Algorithmen generieren, insbesondere im Zusammenhang mit AWS SDKs. Fügen Sie Ihrem Skript eine Eingabeaufforderung hinzu, die die gewünschte Funktion angibt.
Dieses Beispiel zeigt, wie Sie ein Wörterbuch mit Benutzer-ID-Schlüsseln zur Benennung von Werten und anschließend mithilfe des Bubble-Sort-Algorithmus eine Sortierfunktion generieren.
Eingabe:
```
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
'''
```
Ausgabe:
```
@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)
```
Darüber hinaus können Sie Eingabeaufforderungen für Standardverfahren erstellen. In diesem Beispiel erstellt der Benutzer eine Aufforderung, das Wörterbuch in einer Amazon DynamoDB-Tabelle zu speichern. Zu Beginn des Skripts fügt der Benutzer eine Aufforderung zum Hinzufügen von DynamoDB-Bibliotheken hinzu, um Amazon Q Developer zusätzlichen Kontext zur Verfügung zu stellen.
Eingabe:
```
'''
Add libraries for Amazon Dynamo DB
'''
```
Ausgabe:
```
'''
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')
```
Jetzt kann der Benutzer Amazon Q ganz einfach um Hilfe beim Speichern des Wörterbuchs in DynamoDB bitten.
Eingabe:
```
'''
function to store the above sorted dict to dynamodb table named users
'''
```
Ausgabe:
```
@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'])
```
## Generieren Sie Komponententests
Mit integrierten Kommentaren kann Amazon Q Developer Komponententests generieren, um Assertionen und andere Tests durchzuführen. In diesem Beispiel bittet der Benutzer Amazon Q, geeignete Bibliotheken für Komponententests zu generieren, um den Kontext des Testskripts festzulegen. Dann bittet der Benutzer Amazon Q, eine Testfunktion für die `sort_user_id_name_map` Funktion zu schreiben.
Eingabe:
```
'''
Import all the required unit test libraries for python and then generate a unit test for sort_user_id_name_map function.
'''
```
Ausgabe:
```
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()
```
Darüber hinaus werden in einem Chat zwischen dem Benutzer und Amazon Q Developer Komponententests vorgeschlagen und generiert, die auf den Codeeingabeaufforderungen des Benutzers basieren. Weitere Informationen finden Sie unter [Chat-Beispiele](examples-chat.md).