Summary  
This chapter explains how to access individual characters in a string using positive and negative indexing and how to determine the length of a string using the len() function.

General domain of usage  
Grocery store data management (e.g., accessing product names and calculating string lengths)

**Strings in Python** sind Zeichenfolgen, bei denen jedem Zeichen, einschließlich Leerzeichen, eine **bestimmte Position oder ein Index** zugewiesen wird.
Das Zugreifen auf diese Zeichen mittels Indexierung und das Bestimmen der Länge von Strings mit der Funktion `len()` gehören zu den grundlegenden Fähigkeiten in Python.

Sieh dir das folgende Video an, in dem Alex demonstriert, wie **Indexierung** und die Funktion `len()` effektiv zur Interaktion mit Strings genutzt werden können.



In Python beginnt die Indexierung bei `0`, sodass das erste Zeichen eines Strings den Index `0` hat, das zweite den Index `1` und so weiter. Dies wird häufig als die `n-1`-Regel bezeichnet, wobei `n` die Anzahl der Zeichen im String ist. Zur besseren Veranschaulichung betrachte den String `"Apple"`:

## Negative Indexierung

Im Gegensatz dazu ermöglicht die **negative Indexierung**, **Zeichen vom Ende** des Strings aus zu zählen, anstatt vom Anfang.

Diese Methode ist besonders nützlich, wenn du **auf die letzten Elemente** eines Strings zugreifen möchtest, ohne die genaue Länge zu kennen. Das letzte Zeichen des Strings hat den Index `-1`, das vorletzte den Index `-2` und so weiter.

Betrachten wir denselben String, `"Apple"`, **mit negativen Indizes**, um zu verdeutlichen, wie jedes Zeichen vom Ende aus angesprochen werden kann:


## Beispielanwendung

Grundlagen der **String-Indizierung**.
Dieses Beispiel verwenden, um **verschiedene Zeichen** aus dem String auszugeben. Auch negative Indizierung ausprobieren.


grocery_item = "Milk"

# Accessing the first and last character using indexing
first_character = grocery_item[0]  # 'M'
last_character = grocery_item[-1]  # 'k', using negative indexing for the last character

print("First character:", first_character)
print("Last character:", last_character)

Nun eine **Zeichenkette mit Leerzeichen** betrachten und die Funktion `len()` verwenden, um zu sehen, **wie Leerzeichen als Zeichen gezählt werden**.

Das Verständnis, dass Leerzeichen in Python als Zeichen gelten, ermöglicht eine präzise Bearbeitung von Zeichenketten, insbesondere wenn sie Teil der Daten sind.

store_name = "Green Valley Market"

# Find the length of the string, which includes spaces
length_of_name = len(store_name)  # Includes spaces in the count

# Accessing a character in a position after a space
character_after_space = store_name[6]  # 'V'

print("Length of store name:", length_of_name)
print("Character after the space:", character_after_space)

import unittest
import user_code
from io import StringIO
from contextlib import redirect_stdout
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_grocery_item_defined(self):
        try:
            _dynamic_test(
                self,
                hasattr(user_code, 'grocery_item'),
                'grocery_item is defined',
                'Expected grocery_item to be defined.'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_length_of_item_defined(self):
        try:
            expected = len(user_code.grocery_item)
            actual = getattr(user_code, 'length_of_item', None)
            _dynamic_test(
                self,
                actual == expected,
                f'length_of_item is correct: {expected}',
                f'Expected length_of_item to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_first_char_defined_and_correct(self):
        try:
            expected = user_code.grocery_item[0]
            actual = getattr(user_code, 'first_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'first_char is correct: {expected}',
                f'Expected first_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_second_char_defined_and_correct(self):
        try:
            second_word_start = user_code.grocery_item.find(' ') + 1
            expected = user_code.grocery_item[second_word_start]
            actual = getattr(user_code, 'second_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'second_char is correct: {expected}',
                f'Expected second_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_third_char_defined_and_correct(self):
        try:
            second_word_start = user_code.grocery_item.find(' ') + 1
            third_word_start = user_code.grocery_item.find(' ', second_word_start) + 1
            expected = user_code.grocery_item[third_word_start]
            actual = getattr(user_code, 'third_char', None)
            _dynamic_test(
                self,
                actual == expected,
                f'third_char is correct: {expected}',
                f'Expected third_char to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char1_defined_and_correct(self):
        try:
            expected = user_code.grocery_item[-1]
            actual = getattr(user_code, 'last_char1', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char1 is correct: {expected}',
                f'Expected last_char1 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char2_defined_and_correct(self):
        try:
            second_word_end = user_code.grocery_item.find(' ', user_code.grocery_item.find(' ') + 1) - 1
            expected = user_code.grocery_item[second_word_end]
            actual = getattr(user_code, 'last_char2', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char2 is correct: {expected}',
                f'Expected last_char2 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

    def test_last_char3_defined_and_correct(self):
        try:
            first_word_end = user_code.grocery_item.find(' ') - 1
            expected = user_code.grocery_item[first_word_end]
            actual = getattr(user_code, 'last_char3', None)
            _dynamic_test(
                self,
                actual == expected,
                f'last_char3 is correct: {expected}',
                f'Expected last_char3 to be {expected}, but got {actual}'
            )
        except Exception as e:
            self.fail(f"Test failed due to unexpected error: {e}")

if __name__ == '__main__':
    unittest.main()

test_main.py

Python ist eine hochentwickelte, interpretierte, universell einsetzbare Programmiersprache. Im Gegensatz zu Sprachen wie HTML, CSS und JavaScript, die hauptsächlich in der Webentwicklung verwendet werden, zeichnet sich Python durch Vielseitigkeit in verschiedenen Bereichen wie Softwareentwicklung, Data Science und Back-End-Entwicklung aus. Dieser Kurs führt Sie durch die grundlegenden Konzepte von Python und vermittelt Ihnen die Fähigkeiten, eigene Funktionen zu erstellen.

In diesem Abschnitt werden die Grundlagen von Python behandelt.
Sie lernen Ihre Arbeitsumgebung kennen, führen einfache mathematische Operationen durch und geben Ihre Ergebnisse aus.

In diesem Abschnitt erfahren Sie, wie Sie Elemente wie Zahlen und Text im Computerspeicher speichern und sie anhand ihres Namens abrufen können. Zusätzlich erhalten Sie eine Einführung in die Textmanipulation in Python.

In diesem Abschnitt werden Sie den booleschen Datentyp untersuchen und erfahren, wie er verwendet wird,
um Programme zu entwickeln, die auf bestimmte Bedingungen reagieren.

In diesem Abschnitt werden Sie weiterhin Datentypen kennenlernen und erfahren,
wie verschiedene Attribute in einer einzigen Variablen mithilfe von Listen, Tupeln und Dictionaries organisiert werden können.

In diesem Abschnitt lernen Sie, wie man Schleifen in Python erstellt — eine grundlegende Fähigkeit
zum Iterieren durch Listen, Tupel und Dictionaries.

Zum Abschluss dieses Einführungskurses werden einige eingebaute Funktionen untersucht und anschließend eigene entwickelt.

Welche dieser Möglichkeiten ist eine korrekte Methode, um eine Variable zu erstellen?

Versuchen Sie zu erraten, was dieser Code macht.

Gegeben ist die Zeichenkette `"Banana"`. Welcher Code gibt das erste Zeichen zurück?

String-Indizierung und Länge

Negative Indexierung

Beispielanwendung

Lösung