It is a case sensitive, non-mutable sequence of characters marked under quotation. It can contain alphabets, digits, white spaces and special characters. In Python, a string is a sequence of characters enclosed within either single quotes (‘ ‘), double quotes (” “), or triple quotes (”’ ”’ or “”” “””). You can’t mix single and double quotes in the same string or you’ll get a syntax error. 

Single quotes

my_string1 = ‘Hello, World!’

Double quotes

my_string2 = “Python Programming”

Triple quotes for multiline strings

my_string3 = ”’This is a
multiline
string.”’

Three pair of quotes are used when you have to define a multiline string or single quotes are part of string. A backslash ‘\’ can also be used to treat quotes as characters under string.

Strings are immutable, meaning once they are created, their contents cannot be changed.

Few key things that make strings special in Python:

1. Immutability:

Unlike many other data types in Python where you can modify the contents of a variable, strings are immutable. This means that once a string is created, its content cannot be changed.

For instance:

Python

message = "Hello, world!"
# Trying to modify a character
message[0] = 'X'  # This will cause an error!

# You can reassign the variable to a new string
modified_message = 'X' + message[1:]
print(modified_message)  # Output: Xello, world!

In this example, attempting to directly change the first character of message results in an error. However, you can create a new string (modified_message) by combining characters or using string methods like slicing.

2. Sequence of Characters:

Strings are essentially ordered sequences of characters. Each character has its own index position, starting from 0. This allows you to access and manipulate individual characters or substrings within the string using indexing and slicing techniques.

3. Rich Set of Built-in Methods:

Python provides a comprehensive library of built-in string methods that empower you to perform various operations on strings. These methods cover aspects like:

• Case conversion (upper(), lower())
• Searching (find(), count())
• Modification (replace(), split(), join())
• Extraction (strip())
• Validation (isalnum(), isalpha())

These methods make string manipulation efficient and avoid the need to write complex loops or functions for common tasks.

4. Unicode Support:

Python strings are inherently unicode strings, meaning they can represent a wide range of characters from different languages and alphabets. This makes Python strings versatile for handling text data from various cultural contexts.

Some commonly used string functions in Python:

1. Conversion Functions:
   • upper(): Converts all characters in the string to uppercase.
   • lower(): Converts all characters in the string to lowercase.
   • capitalize(): Capitalizes the first character of the string.
   • title(): Converts the first character of each word to uppercase.
2. Search and Replace Functions:
   • find(substring): Returns the lowest index in the string where substring is found.
   • rfind(substring): Returns the highest index in the string where substring is found.
   • index(substring): Like find(), but raises ValueError if the substring is not found.
   • rindex(substring): Like rfind(), but raises ValueError if the substring is not found.
   • count(substring): Returns the number of occurrences of substring in the string.
   • replace(old, new): Returns a copy of the string with all occurrences of substring old replaced by new.
3. Substring Functions:
   • startswith(prefix): Returns True if the string starts with the specified prefix, otherwise False.
   • endswith(suffix): Returns True if the string ends with the specified suffix, otherwise False.
   • strip(): Removes leading and trailing whitespace.
   • lstrip(): Removes leading whitespace.
   • rstrip(): Removes trailing whitespace.
   • split(sep): Splits the string into a list of substrings using the specified separator.
   • rsplit(sep): Splits the string from the right end.
   • partition(sep): Splits the string into three parts using the specified separator. Returns a tuple with (head, separator, tail).
   • rpartition(sep): Splits the string from the right end.
4. String Formatting Functions:
   • format(): Formats the string.
   • join(iterable): Concatenates each element of the iterable (such as a list) to the string.
5. String Testing Functions:
   • isalpha(): Returns True if all characters in the string are alphabetic.
   • isdigit(): Returns True if all characters in the string are digits.
   • isalnum(): Returns True if all characters in the string are alphanumeric (letters or numbers).
   • isspace(): Returns True if all characters in the string are whitespace.
6. Miscellaneous Functions:
   • len(): Returns the length of the string.
   • ord(): Returns the Unicode code point of a character.
   • chr(): Returns the character that corresponds to the Unicode code point.

Examples:-

to get commonLetters from two string with case and duplicates ignored and the result sorted alpabetically

def commonLetters(str1,str2):
    common = ""
    for i in str1:
        if i in str2 and i not in common:
            common += i
    return "".join(sorted(common))

Looping over a String

In Python, you can use a for loop to iterate over each character in a string. To loop over a string means to start with the first character in a string(Position 0) and iterate over each character until the end of the string( Position- Length-1).

Strings are objects that contain a sequence of single-character strings.

A single letter is classified as a string in Python. For example, string[0] is considered a string even though it is just a single character.

Here’s how you can do it-Loooping Over a String:

my_string = "Hello, World!"

for char in my_string:
    print(char)

Slicing Strings:

You can slice strings using the syntax [start:stop:step], where:

• start: The starting index of the slice (inclusive).
• stop: The ending index of the slice (exclusive).
• step: The step or increment between characters (optional).

If you try to access an index that’s larger than the length of your string, you’ll get an IndexError. This is because you’re trying to access something that doesn’t exist!

You can also access indexes from the end of the string going towards the start of the string by using negative values. The index [-1] would access the last character of the string, and the index [-2] would access the second-to-last character.

Example:

my_string = "Python Programming"

# Slicing from index 7 to the end
substring1 = my_string[7:]
print(substring1)  # Output: Programming

# Slicing from index 0 to 6
substring2 = my_string[:6]
print(substring2)  # Output: Python

# Slicing from index 7 to 13 with step 2
substring3 = my_string[7:13:2]
print(substring3)  # Output: Porm

string1 = “Greetings, Earthlings”

print(string1[0])   # Prints “G”

print(string1[4:8]) # Prints “ting”

print(string1[11:]) # Prints “Earthlings”

print(string1[:5])  # Prints “Greet”

If your index is beyond the end of the string, Python returns an empty string. An optional way to slice an index is by the stride argument, indicated by using a double colon. This allows you to skip over the corresponding number of characters in your index, or if you’re using a negative stride, the string prints backwards.

print(string1[0::2])    # Prints “Getns atlns”

print(string1[::-1])    # Prints “sgnilhtraE ,sgniteerG”

Using the str.format() method String Formatting

The str.format() method is a powerful tool in Python for string formatting. It allows you to create dynamic strings by inserting values into placeholders within a string template. Here’s a basic overview of how it works:

Basic Usage:

You start with a string containing placeholder curly braces {} where you want to insert values, and then you call the format() method on that string with the values you want to insert.

Example:

name = "John"
age = 30
print("My name is {} and I am {} years old.".format(name, age))

My name is John and I am 30 years old.

Positional Arguments:

You can pass values to the format() method in the order that corresponds to the order of the placeholders in the string.

Example:

print("My name is {} and I am {} years old.".format("Alice", 25))
My name is Alice and I am 25 years old.

Keyword Arguments:

Alternatively, you can pass values using keyword arguments, where the keys match the names of the placeholders.

Example:

print("My name is {name} and I am {age} years old.".format(name="Bob", age=28))

Output:

My name is Bob and I am 28 years old.


Formatting:

You can also specify formatting options within the placeholders to control the appearance of the inserted values, such as precision for floating-point numbers or padding for strings.

Example:

pi = 3.14159
print("The value of pi is {:.2f}".format(pi))

Output:

The value of pi is 3.14

Accessing Arguments by Position:

You can access arguments out of order and even multiple times by specifying their positions within the curly braces.

Example:

print("{1} {0} {1}".format("be", "or", "not"))

Output:

or be or

Guess the ERROR:-




Using Dictionary for Named Placeholders:

You can use a dictionary to specify values for named placeholders.

Example:

data = {'name': 'Sam', 'age': 35}
print("My name is {name} and I am {age} years old.".format(**data))

Output:

My name is Sam and I am 35 years old.

The str.format() method provides great flexibility and readability for string formatting in Python, making it a versatile tool for a wide range of use cases. You can also put a formatting expression inside the curly brackets, which lets you alter the way the string is formatted. For example, the formatting expression {:.2f} means that you’d format this as a float number, with two digits after the decimal dot. The colon acts as a separator from the field name, if you had specified one. You can also specify text alignment using the greater than operator: >. For example, the expression {:>3.2f} would align the text three spaces to the right, as well as specify a float number with two decimal places.

Split and Join Functions- Really great!!

1. split() function:

The split() function splits a string into a list of substrings based on a specified separator.

Syntax: list_of_words = string.split(separator)

Examples:

# Split a sentence by spaces text = "This is a string to be split."

word_list = text.split() print(word_list)

# Output: ['This', 'is', 'a', 'string', 'to', 'be', 'split.']

# Split a CSV string by commas

csv_data = "name,age,city\nAlice,30,New York\nBob,25,Los Angeles"

data_list = csv_data.split("\n")

# Split by newlines first for row in data_list:

fields = row.split(",") # Split each row by commas within the loop print(fields)

# Output: [['name', 'age', 'city'], ['Alice', '30', 'New York'], ['Bob', '25', 'Los Angeles']] # Split with a custom delimiter

code_snippet = "print('Hello, world!')"

words = code_snippet.split("'")

# Split by single quotes print(words)

# Output: ['print(', 'Hello, world!', ')']

string: The string you want to split.

separator (optional): The delimiter used to split the string. If not specified, whitespace (spaces, tabs, newlines) is used by default.

2. join() function:

The join() function joins the elements of an iterable (like a list) into a single string, inserting a separator between each element.

Syntax:joined_string = separator.join(iterable)

separator: The string to insert between elements.

iterable: The iterable (list, tuple, etc.) containing the elements to join.

Examples:

words = ["Hello", "world", "how", "are", "you?"]

joined_text = " ".join(words)

# Join with spaces print(joined_text)

# Output: Hello world how are you?

# Join with a custom separator

data = ["apple", "banana", "cherry"]

comma_separated = ",".join(data)

# Join with commas

print(comma_separated)

# Output: apple,banana,cherry

# Join lines for a multi-line

string lines = ["This is line 1.", "This is line 2."]

multiline_text = "\n".join(lines)

print(multiline_text)

# Output: This is line 1.

# This is line 2.

Key Points:

• Both split() and join() work with strings and iterables.
• split() returns a list of substrings, while join() returns a single string.
• You can use custom separators for both functions.
• These functions are versatile for various string manipulation tasks.

Examples

1.How to check if a string in palindrome in python

:-

You can check if a string is a palindrome in Python by comparing the string with its reverse. If the string is the same when reversed, it’s a palindrome. Here’s a simple way to do it:

def is_palindrome(s):
    # Remove spaces and convert to lowercase for case-insensitive comparison
    s = s.replace(" ", "").lower()
    # Compare the string with its reverse
    return s == s[::-1]

# Test the function
print(is_palindrome("radar"))  # Output: True
print(is_palindrome("hello"))  # Output: False

This function is_palindrome() takes a string s as input, removes spaces and converts it to lowercase for case-insensitive comparison. Then, it compares the original string s with its reverse using slicing s[::-1]. If they are equal, the function returns True, indicating that the string is a palindrome; otherwise, it returns False.

2. Transform to pig Latin

Pig Latin: simple text transformation that modifies each word moving the first character to the end and appending “ay” to the end.

You can create a Python function to convert text into Pig Latin by following these steps:

1. Split the text into words.
2. For each word:
   • Move the first character to the end of the word.
   • Append “ay” to the end of the word.
3. Join the modified words back into a single string.

Here’s the implementation of the function:

def pig_latin(text):
    # Split the text into words
    words = text.split()
    # List to store Pig Latin words
    pig_latin_words = []
    # Iterate over each word
    for word in words:
        # Move the first character to the end and append "ay"
        pig_latin_word = word[1:] + word[0] + "ay"
        # Append the modified word to the list
        pig_latin_words.append(pig_latin_word)
    # Join the Pig Latin words back into a single string
    pig_latin_text = " ".join(pig_latin_words)
    return pig_latin_text

# Test the function
text = "hello world"
print(pig_latin(text))  # Output: "ellohay orldway"

This function splits the input text into words, processes each word to convert it into Pig Latin, and then joins the modified words back into a single string. You can test it with different input texts to see how it transforms them into Pig Latin.