Diese Seite wurde von der Cloud Translation API übersetzt.

Kursaufgaben und Noten verwalten

Die Classroom-Benutzeroberfläche unterstützt fünf Arten von Kursaufgaben: Aufgaben, Quizaufgaben, Kurzantwort-Fragen, Multiple-Choice-Fragen und Materialien. Die Classroom API unterstützt derzeit drei dieser Typen, die für die API als CourseWorkType bezeichnet werden: Aufgaben, Kurzantwort-Fragen und Multiple-Choice-Fragen.

Für diese Funktion können Sie die Kurs-Ressource verwenden. Sie stellt eine Aufgabe oder Frage dar, die Schülern oder Studenten in einem bestimmten Kurs zugewiesen wurde, einschließlich zusätzlicher Materialien und Details wie Abgabetermin oder maximaler Punktzahl.

Neben der Ressource „Kursarbeit“ können Sie abgeschlossene Aufgaben auch mit der Ressource StudentSubmission verwalten. In den folgenden Abschnitten werden diese ausführlich beschrieben.

Aufgaben erstellen

Aufgaben können nur im Namen des Kursleiters erstellt werden. Wenn Sie versuchen, im Namen eines Kursteilnehmers Aufgaben in einem Kurs zu erstellen, wird der Fehler 403 PERMISSION_DENIED angezeigt. Ebenso können Domainadministratoren keine Zuweisungen für Kurse erstellen, die sie nicht leiten. Wenn Sie dies über die API tun, wird außerdem der Fehler 403 PERMISSION_DENIED zurückgegeben.

Wenn Sie Zuweisungen mit der Methode courses.courseWork.create erstellen, können Sie Links als materials anhängen, wie im Beispielcode unten gezeigt:

Java

classroom/snippets/src/main/java/CreateCourseWork.java

Auf GitHub ansehen

CourseWork courseWork = null;
try {
  // Create a link to add as a material on course work.
  Link articleLink =
      new Link()
          .setTitle("SR-71 Blackbird")
          .setUrl("https://www.lockheedmartin.com/en-us/news/features/history/blackbird.html");

  // Create a list of Materials to add to course work.
  List<Material> materials = Arrays.asList(new Material().setLink(articleLink));

  /* Create new CourseWork object with the material attached.
  Set workType to `ASSIGNMENT`. Possible values of workType can be found here:
  https://developers.google.com/classroom/reference/rest/v1/CourseWorkType
  Set state to `PUBLISHED`. Possible values of state can be found here:
  https://developers.google.com/classroom/reference/rest/v1/courses.courseWork#courseworkstate */
  CourseWork content =
      new CourseWork()
          .setTitle("Supersonic aviation")
          .setDescription(
              "Read about how the SR-71 Blackbird, the world’s fastest and "
                  + "highest-flying manned aircraft, was built.")
          .setMaterials(materials)
          .setWorkType("ASSIGNMENT")
          .setState("PUBLISHED");

  courseWork = service.courses().courseWork().create(courseId, content).execute();

  /* Prints the created courseWork. */
  System.out.printf("CourseWork created: %s\n", courseWork.getTitle());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf("The courseId does not exist: %s.\n", courseId);
  } else {
    throw e;
  }
  throw e;
} catch (Exception e) {
  throw e;
}
return courseWork;

Python

classroom/snippets/classroom_create_coursework.py

Auf GitHub ansehen

from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_create_coursework(course_id):

    """
    Creates the coursework the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member

    try:
        service = build('classroom', 'v1', credentials=creds)
        coursework = {
            'title': 'Ant colonies',
            'description': '''Read the article about ant colonies
                              and complete the quiz.''',
            'materials': [
                {'link': {'url': 'http://example.com/ant-colonies'}},
                {'link': {'url': 'http://example.com/ant-quiz'}}
            ],
            'workType': 'ASSIGNMENT',
            'state': 'PUBLISHED',
        }
        coursework = service.courses().courseWork().create(
            courseId=course_id, body=coursework).execute()
        print(f"Assignment created with ID {coursework.get('id')}")
        return coursework

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error


if __name__ == '__main__':
    # Put the course_id of course whose coursework needs to be created,
    # the user has access to.
    classroom_create_coursework(453686957652)

Das Ergebnis enthält eine vom Server zugewiesene Kennung, mit der in anderen API-Anfragen auf die Zuweisung verwiesen werden kann.

Die Felder title und workType sind Pflichtfelder. Alle anderen sind optional. Wenn state nicht angegeben ist, wird ein Aufgabenentwurf erstellt.

Wenn Sie verknüpfte Aufgaben in eine Aufgabe einbinden möchten, die über die Classroom API erstellt wurde, verwenden Sie eine Linkressource und geben Sie die Ziel-URL an. Classroom ruft den Titel und das Thumbnail automatisch ab. Die Classroom API unterstützt außerdem Google Drive- und YouTube-Materialien, die auf ähnliche Weise in eine DriveFile-Ressource oder eine YouTubeVideo-Ressource aufgenommen werden können.

Wenn Sie ein Fälligkeitsdatum festlegen möchten, legen Sie für die Felder dueDate und dueTime die entsprechende UTC-Zeit fest. Das Fälligkeitsdatum muss in der Zukunft liegen.

Aufgaben und Fragen abrufen

Sie können Aufgaben und Fragen für Schüler/Studenten und Lehrkräfte des entsprechenden Kurses oder von einem Domainadministrator abrufen. Rufen Sie mit „courses.courseWork.get“ eine bestimmte Aufgabe oder Frage ab. Verwenden Sie „courses.courseWork.list“, um alle Zuweisungen oder Fragen abzurufen (optional, die bestimmten Kriterien entsprechen).

Der erforderliche Bereich hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Wenn der Nutzer Student ist, verwenden Sie einen der folgenden Bereiche:

https://www.googleapis.com/auth/classroom.coursework.me.readonly
https://www.googleapis.com/auth/classroom.coursework.me

Wenn der Nutzer eine Lehrkraft oder ein Domainadministrator ist, verwenden Sie einen der folgenden Bereiche:

https://www.googleapis.com/auth/classroom.coursework.students.readonly
https://www.googleapis.com/auth/classroom.coursework.students

Die Berechtigung zum Abrufen einer Aufgabe oder Frage impliziert keine Berechtigung für den Zugriff auf Materialien oder Materialmetadaten. In der Praxis bedeutet das, dass ein Administrator den Titel einer angehängten Drive-Datei möglicherweise nicht sieht, wenn er kein Teilnehmer des Kurses ist. Wenn Sie Administratoren Zugriff auf Nutzerdateien gewähren möchten, finden Sie entsprechende Informationen unter Domainweite Delegierung.

Antworten von Schülern oder Studenten verwalten

Eine Ressource vom Typ StudentSubmission stellt die Aufgabe und Note eines Schülers/Studenten für eine Aufgabe oder Frage dar. Eine StudentSubmission-Ressource wird implizit für jeden Schüler/Studenten erstellt, wenn eine neue Frage oder Aufgabe erstellt wird.

Aufgaben von Schülern/Studenten können nur von dem Developer Console-Projekt bearbeitet werden, mit dem die entsprechende CourseWork-Ressource erstellt wurde. Außerdem wird geprüft, ob der anfragende Nutzer die richtigen Berechtigungen hat. Änderungen können von jedem OAuth2-Client in diesem Projekt vorgenommen werden. Das Feld associatedWithDeveloper gibt an, ob der aktuelle OAuth2-Client eine bestimmte StudentSubmission ändern kann.

In den folgenden Abschnitten werden häufige Aktionen beschrieben, mit denen Antworten von Schülern oder Studenten verwaltet werden.

Antworten von Schülern oder Studenten abrufen

Schüler und Studenten können ihre eigenen abgegebenen Aufgaben abrufen, Lehrkräfte können abgegebene Aufgaben für alle Lernenden in ihren Kursen abrufen und Domain-Administratoren können alle abgegebenen Aufgaben von allen Schülern oder Studenten in ihrer Domain abrufen. Jeder abgegebene Schüler erhält eine Kennung. Wenn Sie sie kennen, können Sie sie mit courses.courseWork.studentSubmissions.get abrufen.

Verwenden Sie die Methode courses.courseWork.studentSubmissions.list, um StudentSubmission-Ressourcen abzurufen, die einigen Kriterien entsprechen, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ListSubmissions.java

Auf GitHub ansehen

List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf(
          "Student id (%s), student submission id (%s)\n",
          submission.getUserId(), submission.getId());
    }
  }
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s) or courseWorkId (%s) does not exist.\n", courseId, courseWorkId);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmissions;

Python

classroom/snippets/classroom_list_submissions.py

Auf GitHub ansehen

from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_submissions(course_id, coursework_id):
    """
    Creates the courses the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    submissions = []
    page_token = None

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            response = coursework.studentSubmissions().list(
                pageToken=page_token,
                courseId=course_id,
                courseWorkId=coursework_id,
                pageSize=10).execute()
            submissions.extend(response.get('studentSubmissions', []))
            page_token = response.get('nextPageToken', None)
            if not page_token:
                break

        if not submissions:
            print('No student submissions found.')

        print('Student Submissions:')
        for submission in submissions:
            print(f"Submitted at:"
                  f"{(submission.get('id'), submission.get('creationTime'))}")

    except HttpError as error:
        print(f"An error occurred: {error}")
        submissions = None
    return submissions


if __name__ == '__main__':
    # Put the course_id and coursework_id of course whose list needs to be
    # submitted.
    classroom_list_submissions(453686957652, 466086979658)

Rufen Sie StudentSubmission-Ressourcen ab, die zu einem bestimmten Studenten gehören. Dazu geben Sie den Parameter userId an, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ListStudentSubmissions.java

Auf GitHub ansehen

List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    // Set the userId as a query parameter on the request.
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .set("userId", userId)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf("Student submission: %s.\n", submission.getId());
    }
  }

Python

classroom/snippets/classroom_list_student_submissions.py

Auf GitHub ansehen

from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_student_submissions(course_id, coursework_id, user_id):
    """
    Creates the courses the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    submissions = []
    page_token = None

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            response = coursework.studentSubmissions().list(
                pageToken=page_token,
                courseId=course_id,
                courseWorkId=coursework_id,
                userId=user_id).execute()
            submissions.extend(response.get('studentSubmissions', []))
            page_token = response.get('nextPageToken', None)
            if not page_token:
                break

        if not submissions:
            print('No student submissions found.')

        print('Student Submissions:')
        for submission in submissions:
            print(f"Submitted at:"
                  f"{(submission.get('id'), submission.get('creationTime'))}")

    except HttpError as error:
        print(f"An error occurred: {error}")
    return submissions


if __name__ == '__main__':
    # Put the course_id, coursework_id and user_id of course whose list needs
    # to be submitted.
    classroom_list_student_submissions(453686957652, 466086979658, "me")

Schüler/Studenten werden durch die eindeutige ID oder E-Mail-Adresse des Nutzers identifiziert, die vom Google Admin SDK zurückgegeben wird. Der aktuelle Nutzer kann sich mit der Kurzschreibweise "me" auch auf seine eigene ID beziehen.

Es ist auch möglich, die abgegebenen Aufgaben aller Aufgaben in einem Kurs abzurufen. Verwenden Sie dazu das Literal "-" als courseWorkId, wie im folgenden Beispiel gezeigt:

Java

service.courses().courseWork().studentSubmissions()
    .list(courseId, "-")
    .set("userId", userId)
    .execute();

Python

service.courses().courseWork().studentSubmissions().list(
    courseId=<course ID or alias>,
    courseWorkId='-',
    userId=<user ID>).execute()

Der erforderliche Bereich hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Verwenden Sie den folgenden Bereich, wenn der Nutzer eine Lehrkraft oder ein Domainadministrator ist:

https://www.googleapis.com/auth/classroom.coursework.students.readonly
https://www.googleapis.com/auth/classroom.coursework.students

Verwenden Sie den folgenden Bereich, wenn der Nutzer ein Student ist:

https://www.googleapis.com/auth/classroom.coursework.me.readonly
https://www.googleapis.com/auth/classroom.coursework.me

Die Berechtigung zum Abrufen einer abgegebenen Aufgabe eines Schülers bedeutet nicht, dass er Zugriff auf Anhänge oder Metadaten von Anhängen hat. In der Praxis bedeutet das, dass ein Administrator den Titel einer angehängten Drive-Datei möglicherweise nicht sieht, wenn er kein Teilnehmer des Kurses ist. Informationen dazu, wie Sie Administratoren Zugriff auf Nutzerdateien gewähren, finden Sie im Leitfaden Domainweite Delegierung.

Hinzufügen von Anhängen zu Antworten von Schülern/Studenten

Sie können Links an abgegebene Aufgaben von Schülern/Studenten anhängen, indem Sie eine Ressource vom Typ Link, DriveFile oder YouTubeVideo anhängen. Dazu wird courses.courseWork.studentSubmissions.modifyAttachments verwendet, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ModifyAttachmentsStudentSubmission.java

Auf GitHub ansehen

StudentSubmission studentSubmission = null;
try {
  // Create ModifyAttachmentRequest object that includes a new attachment with a link.
  Link link = new Link().setUrl("https://en.wikipedia.org/wiki/Irrational_number");
  Attachment attachment = new Attachment().setLink(link);
  ModifyAttachmentsRequest modifyAttachmentsRequest =
      new ModifyAttachmentsRequest().setAddAttachments(Arrays.asList(attachment));

  // The modified studentSubmission object is returned with the new attachment added to it.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .modifyAttachments(courseId, courseWorkId, id, modifyAttachmentsRequest)
          .execute();

  /* Prints the modified student submission. */
  System.out.printf(
      "Modified student submission attachments: '%s'.\n",
      studentSubmission.getAssignmentSubmission().getAttachments());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

Python

classroom/snippets/classroom_add_attachment.py

Auf GitHub ansehen


def classroom_add_attachment(course_id, coursework_id, submission_id):
    """
    Adds attachment to existing course with specific course_id.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    request = {
        'addAttachments': [
            {'link': {'url': 'http://example.com/quiz-results'}},
            {'link': {'url': 'http://example.com/quiz-reading'}}
        ]
    }

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            coursework.studentSubmissions().modifyAttachments(
                courseId=course_id,
                courseWorkId=coursework_id,
                id=submission_id,
                body=request).execute()

    except HttpError as error:
        print(f"An error occurred: {error}")


if __name__ == '__main__':
    # Put the course_id, coursework_id and submission_id of course in which
    # attachment needs to be added.
    classroom_add_attachment('course_id', 'coursework_id', "me")

Ein Linkanhang wird durch die Ziel-URL definiert. Classroom ruft automatisch den Titel und das Thumbnail ab. Weitere Informationen zu den anderen Materialien finden Sie auf den entsprechenden Referenzseiten.

Die StudentSubmission kann nur von einer Lehrkraft oder vom Eigentümer des Kurses geändert werden. Sie können nur Materials anhängen, wenn der CourseWorkType der abgegebenen Aufgabe ASSIGNMENT ist.

Der erforderliche Bereich hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Verwenden Sie den folgenden Bereich, wenn der Nutzer Lehrkraft ist:

https://www.googleapis.com/auth/classroom.coursework.students

Verwenden Sie den folgenden Bereich, wenn der Nutzer ein Student ist:

https://www.googleapis.com/auth/classroom.coursework.me

Antwortstatus der Lernenden verwalten

Die Antwort eines Schülers/Studenten kann zurückgezogen, abgegeben oder zurückgegeben werden. Das Statusfeld in StudentSubmission gibt den aktuellen Status an. Rufen Sie eine der folgenden Methoden auf, um den Status zu ändern:

Alle diese Methoden haben einen leeren Textkörper. Beispiel:

Java

classroom/snippets/src/main/java/ReturnStudentSubmission.java

Auf GitHub ansehen

try {
  service
      .courses()
      .courseWork()
      .studentSubmissions()
      .classroomReturn(courseId, courseWorkId, id, null)
      .execute();
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}

Python

service.courses().courseWork().studentSubmission().turnIn(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    body={}).execute()

Nur der Eigentümer des StudentSubmission kann die Aufgabe abgeben oder reaktivieren. Nur eine abgegebene Aufgabe kann zurückgefordert werden. Lehrkräfte können nur StudentSubmission zurückgeben, die abgegeben wurden.

Der Wert von assignedGrade or draftGrade wird dadurch nicht geändert. Informationen dazu, wie Sie dem Schüler/Studenten eine Note mitteilen, finden Sie im Abschnitt Aufgaben von Schülern/Studenten benoten.

Schüler/Studenten benoten

Die Ressource StudentSubmission enthält zwei Felder zum Speichern von Noten: assignedGrade (Note, die den Schülern/Studenten angezeigt wird) und draftGrade (vorläufige Note, die nur für Lehrkräfte sichtbar ist). Diese Felder werden mit courses.courseWork.studentSubmissions.patch mit einer Feldmaske aktualisiert, die die entsprechenden Felder enthält, wie im folgenden Beispiel gezeigt.

Java

classroom/snippets/src/main/java/PatchStudentSubmission.java

Auf GitHub ansehen

StudentSubmission studentSubmission = null;
try {
  // Updating the draftGrade and assignedGrade fields for the specific student submission.
  StudentSubmission content =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .get(courseId, courseWorkId, id)
          .execute();
  content.setAssignedGrade(90.00);
  content.setDraftGrade(80.00);

  // The updated studentSubmission object is returned with the new draftGrade and assignedGrade.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .patch(courseId, courseWorkId, id, content)
          .set("updateMask", "draftGrade,assignedGrade")
          .execute();

  /* Prints the updated student submission. */
  System.out.printf(
      "Updated student submission draft grade (%s) and assigned grade (%s).\n",
      studentSubmission.getDraftGrade(), studentSubmission.getAssignedGrade());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

Python

studentSubmission = {
  'assignedGrade': 99,
  'draftGrade': 80
}
service.courses().courseWork().studentSubmissions().patch(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    updateMask='assignedGrade,draftGrade',
    body=studentSubmission).execute()

Bei der Arbeit mit der Classroom-UI können Lehrkräfte erst Noten vergeben, wenn sie zuvor einen Notenentwurf gespeichert haben. Die zugewiesene Note kann dann an einen Schüler/Studenten zurückgegeben werden. Anwendungen müssen dieses Verhalten emulieren. Die Anwendung kann die Aufgabe eines Schülers auf zwei Arten benoten:

Weisen Sie nur draftGrade zu. Dies ist z. B. hilfreich, wenn die Lehrkraft Noten vor dem Abschluss manuell prüfen soll. Schüler/Studenten können Notenentwürfe nicht sehen.
Weisen Sie sowohl draftGrade als auch assignedGrade zu, um eine Aufgabe vollständig zu benoten.

Legen Sie assignedGrade nicht auch ohne draftGrade fest. Wenn Sie nur „assignedGrade“ festlegen, kann dies zu seltsamem Verhalten in der Classroom-UI führen.

Zugewiesene Noten auflisten

Sie können alle Noten für ein bestimmtes Kursaufgabenelement auflisten, indem Sie das Antwortobjekt der Methode courses.courseWork.studentSubmissions.list untersuchen:

Java

ListStudentSubmissionsResponse response = service.courses().courseWork().studentSubmissions()
    .list(courseId, courseWorkId)
    .execute();

if (response.getStudentSubmissions() != null) {
  List<StudentSubmission> submissionList = response.getStudentSubmissions();

  for (StudentSubmission submission : submissionList) {
    System.out.printf("User ID %s, Assigned grade: %s", submission.getUserId(),
        submission.getAssignedGrade());
  }
} else {
  System.out.println("No submissions found.");
}

Python

response = coursework.studentSubmissions().list(
    courseId=course_id,
    courseWorkId=coursework_id,
    pageSize=10).execute()
submissions.extend(response.get('studentSubmissions', []))

if not submissions:
    print('No student submissions found.')

print('Student Submissions:')
for submission in submissions:
    print(f"Submitted at:"
          f"{(submission.get('userId'), submission.get('assignedGrade'))}")