Working with Strings in Python

Strings are one of the most commonly used data types in Python. This module will cover everything from basic string creation and manipulation to advanced string methods, formatting, and handling multiline strings.

Subtopic 1: String Creation and Manipulation

A string in Python is a sequence of characters, and it can be created using single quotes (') or double quotes ("). You can also use triple quotes (''' or """) for multi-line strings.

Creating Strings

Single and Double Quotes: You can use both single and double quotes interchangeably to define a string.
```
string1 = 'Hello, World!'
string2 = "Python is great!"
```
Multiline Strings: You can use triple quotes to create strings that span multiple lines.
```
multiline_string = """This is
a multiline string"""
```

Accessing String Elements

Strings are indexed like lists. You can access individual characters using an index (starting from 0).

text = "Python"
print(text[0])  # Output: 'P'
print(text[-1])  # Output: 'n' (negative index starts from the end)

Slicing Strings

You can slice strings using the [start:end] syntax.

text = "Hello, World!"
print(text[0:5])  # Output: 'Hello'
print(text[:5])   # Output: 'Hello' (if start is omitted, it starts from index 0)
print(text[7:])   # Output: 'World!' (if end is omitted, it goes until the end)

String Concatenation

You can concatenate (combine) strings using the + operator.

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name
print(message)  # Output: 'Hello, Alice'

Repetition of Strings

Strings can be repeated using the * operator.

text = "Hi! "
print(text * 3)  # Output: 'Hi! Hi! Hi! '

Subtopic 2: String Methods and Functions

Python provides a variety of built-in string methods to perform common operations. Below is a list of common string methods and their usage:

Common String Methods

len(): Returns the length of the string.

text = "Python"
print(len(text))  # Output: 6

lower(): Converts all characters to lowercase.

text = "HELLO"
print(text.lower())  # Output: 'hello'

upper(): Converts all characters to uppercase.

text = "hello"
print(text.upper())  # Output: 'HELLO'

capitalize(): Capitalizes the first character and makes all others lowercase.
```
text = "python"
print(text.capitalize())  # Output: 'Python'
```

title(): Capitalizes the first letter of each word.

text = "hello world"
print(text.title())  # Output: 'Hello World'

swapcase(): Swaps uppercase characters to lowercase and vice versa.
```
text = "HeLLo"
print(text.swapcase())  # Output: 'hEllO'
```

strip(): Removes leading and trailing whitespace characters.

text = "  Hello  "
print(text.strip())  # Output: 'Hello'

replace(old, new): Replaces occurrences of a substring with another substring.

text = "Hello, World!"
print(text.replace("World", "Python"))  # Output: 'Hello, Python!'

find(substring): Returns the index of the first occurrence of a substring (returns -1 if not found).
```
text = "Hello, World!"
print(text.find("World"))  # Output: 7
```

count(substring): Returns the number of occurrences of a substring.

text = "Hello, World! World!"
print(text.count("World"))  # Output: 2

startswith(substring): Returns True if the string starts with the specified substring, otherwise False.
```
text = "Python Programming"
print(text.startswith("Python"))  # Output: True
```
endswith(substring): Returns True if the string ends with the specified substring, otherwise False.
```
text = "Python Programming"
print(text.endswith("Programming"))  # Output: True
```

split(separator): Splits the string into a list using a specified separator.

text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)  # Output: ['apple', 'banana', 'cherry']

join(iterable): Joins elements of an iterable into a string, separated by the string on which join() was called.
```
fruits = ["apple", "banana", "cherry"]
print(", ".join(fruits))  # Output: 'apple, banana, cherry'
```
isalpha(): Returns True if all characters in the string are alphabetic.
```
text = "Python"
print(text.isalpha())  # Output: True
```

isdigit(): Returns True if all characters are digits.

text = "12345"
print(text.isdigit())  # Output: True

isspace(): Returns True if the string contains only whitespace characters.
```
text = "   "
print(text.isspace())  # Output: True
```

Subtopic 3: String Formatting Techniques

Python provides several ways to format strings for improved readability and consistency.

1. f-strings (Formatted String Literals)

Introduced in Python 3.6, f-strings allow inline expressions inside string literals.

name = "Vijay"
age = 25
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)  # Output: 'Hello, my name is Vijay and I am 25 years old.'

2. `str.format()` Method

The str.format() method is used to insert variables into a string.

name = "Vijay"
age = 25
greeting = "Hello, my name is {} and I am {} years old.".format(name, age)
print(greeting)  # Output: 'Hello, my name is Vijay and I am 25 years old.'

3. String Concatenation Using `+`

While not recommended for formatting large strings due to inefficiency, you can concatenate strings using +.

greeting = "Hello, my name is " + name + " and I am " + str(age) + " years old."
print(greeting)

Subtopic 4: Handling Multiline Strings

Python handles multiline strings using triple quotes (''' or """). This is particularly useful for long text blocks, docstrings, or multiline messages.

1. Multiline String Assignment

multiline = """This is a
multiline string
in Python."""
print(multiline)

2. Multiline Strings with String Methods

Methods like strip() can also be used with multiline strings to remove unwanted leading or trailing spaces.

multiline = """   This is
   a multiline
   string."""
print(multiline.strip())  # Output: 'This is\na multiline\nstring.'

3. Multiline Strings in Functions

Multiline strings are commonly used in functions as docstrings to explain the functionality of a function.

def my_function():
    """
    This function does something important.
    It performs an operation on numbers.
    """
    pass