Summary
String slicing allows you to extract substrings by specifying start and end indices, and string concatenation uses the + operator to join multiple strings, with optional separators like spaces.

General domain of usage
Text processing

String **slicing** and **concatenation** are **essential techniques** in Python for manipulating sequences of characters. By understanding **how to slice and combine strings** (concatenation), you can efficiently process text data, which is crucial in many programming contexts.

In the following video, Alex will demonstrate the **practical applications** of string slicing and concatenation. Watch closely, as these concepts are key to effective string manipulation:


String slicing allows you to extract substrings from a larger string **by specifying the start and end indices**. The syntax `string[start:end]` is used, where `start` is the index of the **first character** you want to **include**, and `end` is the index **one past the last character** you want to **include**. This technique is especially useful for breaking down and analyzing strings by parts.

## Example Application

Let's take a closer look at how slicing works:


fruit = "Strawberries"

# Slicing the string to get "Straw"
# Remember, the 'w' is indexed at 4 but if we want to include it in the slice, we need to go up to 5 
sliced_fruit = fruit[0:5]

print("Sliced part:", sliced_fruit)

Concatenation is the process of **joining two or more strings end-to-end**, forming a new string. 

This is achieved using the `+` operator, making it straightforward to combine strings for various purposes, such as creating full sentences or generating formatted output.

Here's how you can **concatenate strings** to create a new string:


# Concatenating strings
part1 = "Straw"
part2 = "berry"
new_word = part1 + part2  # "Strawberry"
print("Concatenated word:", new_word)

# If you want to separate the words with a space, you need to add " " between the two parts
print(part1 + " " + part2)  # "Straw berry"

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


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*([,:])\s*', r'\1', text)  
      text = re.sub(r'\s+', ' ', text)  
      return text.strip()

    def test_print_statement_correct(self):
        try:
            f = StringIO()
            with redirect_stdout(f):
                importlib.reload(user_code)
            output = self.normalize_text(f.getvalue().strip())
            expected = self.normalize_text('We have dairy and bakery items: milk, cheese, and bread in aisle 5')
            _dynamic_test(
                self,
                output == expected,
                "Printed correct full statement about dairy and bakery items",
                f"Expected the output to be '{expected}', but got '{output}'"
            )
        except Exception as e:
            self.fail(f"Test failed due to an unexpected error: {e}")

    def test_string_slicing_used(self):
        try:
            with open('user_code.py', 'r') as file:
                user_code_source = file.read()
            tree = ast.parse(user_code_source)
            slice_found = any(isinstance(node, ast.Subscript) for node in ast.walk(tree))
            _dynamic_test(
                self,
                slice_found,
                "Used string slicing to extract items",
                "Expected the code to use string slicing to extract items"
            )
        except Exception as e:
            self.fail(f"Test failed due to an unexpected error: {e}")

    def test_string_concatenation_used(self):
        try:
            with open('user_code.py', 'r') as file:
                user_code_source = file.read()
            tree = ast.parse(user_code_source)
            concat_found = any(isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add) for node in ast.walk(tree))
            _dynamic_test(
                self,
                concat_found,
                "Used string concatenation to build the output",
                "Expected the code to use string concatenation to create the statement"
            )
        except Exception as e:
            self.fail(f"Test failed due to an unexpected error: {e}")


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


test_main.py

Python is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Which of these is a correct way to create a variable?

Given the string `"Banana"`, which code retrieves its first character?

What will be the output of the following code?

String Slicing and Concatenation

Example Application

What to Do

Output Requirements

解答