single_quoted = 'This is a single-quoted string.'
double_quoted = "This is a double-quoted string."

triple_quoted = '''This is a
multiline string.'''

my_string = "Intensity Coding"
print(my_string)

Intensity Coding

# Using triple quotes to define a multi-line string
multi_line_str = """This is a long string that spans
multiple lines and includes special characters like
TAB (\t) and NEWLINEs (\n) which appear as they are."""
print(multi_line_str)

# Normal string with escape characters
print('C:\\nowhere')  # Output: C:\nowhere

# Raw string to ignore escape sequences
print(r'C:\\nowhere')  # Output: C:\\nowhere

This is a long string that spans 
multiple lines and includes special characters like 
TAB (	) and NEWLINEs (
) which appear as they are.
C:\nowhere
C:\\nowhere

my_string = "Intensity Coding"
first_char = my_string[0]  # Access the first character (index 0)
print(first_char)  # Output: 'I'

third_char = my_string[2]  # Access the third character (index 2)
print(third_char)  # Output: 't'

I
t

my_string = "Intensity Coding"
last_char = my_string[-1]  # Access the last character
print(last_char)  # Output: 'g'

second_last_char = my_string[-2]  # Access the second-to-last character
print(second_last_char)  # Output: 'n'

g
n

my_string = "Intensity Coding"
substring = my_string[2:5]  # Get characters from index 2 to 4 (exclusive)
print(substring)  # Output: 'ten'

ten

my_string = "Intensity Coding"
print(my_string[:4])

Inte

my_string = "Intensity Coding"
print(my_string[2:])

tensity Coding

my_string = "Intensity Coding"
print(my_string[-5:-2])

odi

# Merge variable first_name with variable last_name into variable full_name:
first_name = "John"
last_name = "Doe"
full_name = first_name + last_name  # 'JohnDoe'
print(full_name)

JohnDoe

# #To add a space between them, add a " ":
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name  # 'John Doe'
print(full_name)

John Doe

str1 = "Python "
result = str1 * 3  # Result: "Python Python Python "
print(result)

Python Python Python

my_string = "Intensity Coding"
for char in my_string:
    print(char)

I
n
t
e
n
s
i
t
y
 
C
o
d
i
n
g

a = "Intensity Coding" # it is also include blank space
print(len(a))

16

str = "Intensity Coding"
print("Max character: " + max(str))

Max character: y

str = "IntensityCoding"
print("Min character: " + min(str))

Min character: C

text = "Intensity Coding"
character_to_check = "o"

if character_to_check in text:
    print(f"The character '{character_to_check}' exists in the string.")
else:
    print(f"The character '{character_to_check}' does not exist in the string.")

The character 'o' exists in the string.

txt = "Python is easy to learn."
print("easy" in txt)

True

text = "Intensity Coding"
character_to_check = "z"

if character_to_check not in text:
    print(f"The character '{character_to_check}' does not exist in the string.")
else:
    print(f"The character '{character_to_check}' exists in the string.")

The character 'z' does not exist in the string.

txt = "Python is easy to learn."
print("good" not in txt)

True

txt = 'It\'s beautiful.'
print(txt)

It's beautiful.

txt = "This is a backslash: \\"
print(txt)

This is a backslash: \

txt = "Hello\nWorld!"
print(txt)

Hello
World!

txt = "Hello\rWorld!"
print(txt)

Hello
World!

txt = "Hello \bWorld!"
print(txt)

Hello World!

txt = "\110\145\154\154\157"
print(txt)

Hello

txt = "\x48\x65\x6c\x6c\x6f"
print(txt)

Hello

# Basic String Formatting using % Operator
print("The %s is a powerful method for %s!" % ("intensity coding", "Python programming"))
# Output: "The intensity coding is a powerful method for Python programming!"

# Injecting Multiple Strings
action = "explored"
print("She %s and %s new concepts daily!" % ("learned", action))
# Output: "She learned and explored new concepts daily!"

# Formatting Floating-Point Numbers (Precision Handling)
pi_value = 3.141592
print("The value of pi rounded to 4 decimal places: %5.4f" % pi_value)
# Output: "The value of pi rounded to 4 decimal places: 3.1416"

# Formatting Multiple Data Types
variable = 42
formatted_string = "Variable as integer = %d \nVariable as float = %f" % (variable, variable)
print(formatted_string)
# Output:
# Variable as integer = 42
# Variable as float = 42.000000

# Combining String and Number Formatting
score = 98.75
print("Your final score in %s is: %6.2f" % ("intensity coding", score))
# Output: "Your final score in intensity coding is:  98.75"

The intensity coding is a powerful method for Python programming!
She learned and explored new concepts daily!
The value of pi rounded to 4 decimal places: 3.1416
Variable as integer = 42 
Variable as float = 42.000000
Your final score in intensity coding is:  98.75

# Basic String Formatting using format()
print("The {} method is essential in {}.".format("format()", "intensity coding"))
# Output: "The format() method is essential in intensity coding."

# Index-based Insertion
print("{2} {1} {0}".format("coding", "intensity", "Mastering"))
# Output: "Mastering intensity coding"

# Keyword-based Formatting
print("Topic: {topic}, Difficulty: {level}".format(topic="intensity coding", level="Advanced"))
# Output: "Topic: intensity coding, Difficulty: Advanced"

# Reusing Inserted Objects
print("The first {p} was good, but the {p} {p} was tough.".format(p="lesson"))
# Output: "The first lesson was good, but the lesson lesson was tough."

# Floating-Point Precision
pi_value = 3.141592
print("Pi value rounded to 4 decimal places: {:.4f}".format(pi_value))
# Output: "Pi value rounded to 4 decimal places: 3.1416"

# Formatting Different Data Types
num = 42
binary = "{:b}".format(num)
octal = "{:o}".format(num)
hexadecimal = "{:x}".format(num)

print("Binary: {}, Octal: {}, Hex: {}".format(binary, octal, hexadecimal))
# Output: "Binary: 101010, Octal: 52, Hex: 2a"

# Combining String and Number Formatting
score = 95.6789
print("Your final score in {} is: {:6.2f}".format("intensity coding", score))
# Output: "Your final score in intensity coding is:  95.68"

The format() method is essential in intensity coding.
Mastering intensity coding
Topic: intensity coding, Difficulty: Advanced
The first lesson was good, but the lesson lesson was tough.
Pi value rounded to 4 decimal places: 3.1416
Binary: 101010, Octal: 52, Hex: 2a
Your final score in intensity coding is:  95.68

# Basic f-string Usage
topic = "intensity coding"
print(f"Learning {topic} improves problem-solving skills.")
# Output: "Learning intensity coding improves problem-solving skills."

# Arithmetic Operations in f-strings
a, b = 5, 10
print(f"The total difficulty score of {a} and {b} is {2 * (a + b)}.")
# Output: "The total difficulty score of 5 and 10 is 30."

# Using Functions inside f-strings
def coding_hours(level):
    return level * 2

level = 5
print(f"To master {topic}, you need {coding_hours(level)} hours of practice.")
# Output: "To master intensity coding, you need 10 hours of practice."

# Lambda Expressions in f-strings
print(f"Complexity level doubled: {(lambda x: x*2)(3)}")
# Output: "Complexity level doubled: 6"

# Floating-Point Precision
pi_value = 3.141592
print(f"Pi value rounded to 4 decimal places: {pi_value:.4f}")
# Output: "Pi value rounded to 4 decimal places: 3.1416"

# String Alignment with f-strings
language = "Python"
print(f"|{language:<10}|{language:^10}|{language:>10}|")
# Output:
# |Python    |  Python   |    Python|

# Mixing Data Types
score = 99
print(f"Your final score in {topic} is: {score}!")
# Output: "Your final score in intensity coding is: 99!"

Learning intensity coding improves problem-solving skills.
The total difficulty score of 5 and 10 is 30.
To master intensity coding, you need 10 hours of practice.
Complexity level doubled: 6
Pi value rounded to 4 decimal places: 3.1416
|Python    |  Python  |    Python|
Your final score in intensity coding is: 99!

from string import Template

# Using Template Class
template = Template("Welcome to $topic! Let's explore.")
result = template.substitute(topic="intensity coding")
print(result)
# Output: "Welcome to intensity coding! Let's explore."

# Multiple Substitutions
n1 = "intensity"
n2 = "coding"
template = Template("Mastering $n1 $n2 requires consistency.")
print(template.substitute(n1=n1, n2=n2))
# Output: "Mastering intensity coding requires consistency."

# Using Braces to Extend Placeholder
template = Template("Learning ${skill}123 helps in problem-solving.")
print(template.substitute(skill="intensity coding"))
# Output: "Learning intensity coding123 helps in problem-solving."

# Escaping `$` Symbol
template = Template("Price of learning: $$99 for $duration months.")
print(template.substitute(duration=6))
# Output: "Price of learning: $99 for 6 months."

# Handling Missing Values Safely
template = Template("Your next step in $topic is $action.")
print(template.safe_substitute(topic="intensity coding"))
# Output: "Your next step in intensity coding is $action."

# Using Dictionary for Substitution
data = {"subject": "intensity coding", "platform": "Python"}
template = Template("Learn $subject using $platform.")
print(template.substitute(data))
# Output: "Learn intensity coding using Python."

Welcome to intensity coding! Let's explore.
Mastering intensity coding requires consistency.
Learning intensity coding123 helps in problem-solving.
Price of learning: $99 for 6 months.
Your next step in intensity coding is $action.
Learn intensity coding using Python.

# Centering a string with default space padding
string = "intensity coding"
width = 30

centered = string.center(width)
print(centered)
# Output: "       intensity coding       "

# Using a custom character for padding
centered_with_dash = string.center(width, "-")
print(centered_with_dash)
# Output: "-------intensity coding-------"

# When width is smaller than the string length
small_width = 10
print(string.center(small_width))
# Output: "intensity coding" (No changes)

# Centering an empty string
empty_string = ""
print(empty_string.center(10, "*"))
# Output: "**********" (Only padding)

# Uneven padding (left gets priority)
odd_width = 29
print(string.center(odd_width, "*"))
# Output: "*******intensity coding******"

       intensity coding       
-------intensity coding-------
intensity coding
**********
*******intensity coding******

# Convert the first letter of the string to uppercase:
text = "intensity coding is awesome."
modified_text = text.capitalize()
print(modified_text)  # Output: Intensity coding is awesome.

Intensity coding is awesome.

# Convert the string to lowercase using casefold()

text = "INTENSITY CODING"
result = text.casefold()

print(result)  # Output: intensity coding

intensity coding

# Center align the string with '' as padding
text = "intensity coding"
centered_text = text.center(20)
print(centered_text)  # Output:   intensity coding

  intensity coding

# Center align the string with '*' as padding
text = "intensity coding"
centered_text = text.center(30, '*')
print(centered_text)  # Output: *******intensity coding*******

*******intensity coding*******

# Count occurrences of 'i' in the string

text = "intensity coding in an intense world"
count_i = text.count("i")

print(count_i)  # Output: 5

# Count occurrences of 'in' between index 5 and 20
count_in = text.count("in", 5, 20)

print(count_in)  # Output: 2

5
2

# Encode the string using UTF-8 (default)

text = "intensity cødïng"
encoded_text = text.encode()
print(encoded_text)  # Output: b'intensity c\xc3\xb8d\xc3\xafng'

b'intensity c\xc3\xb8d\xc3\xafng'

# Encode using ASCII with different error handling methods
text_special = "intensity cødïng"

print(text_special.encode(encoding="ascii", errors="backslashreplace"))
print(text_special.encode(encoding="ascii", errors="ignore"))
print(text_special.encode(encoding="ascii", errors="namereplace"))
print(text_special.encode(encoding="ascii", errors="replace"))
print(text_special.encode(encoding="ascii", errors="xmlcharrefreplace"))

b'intensity c\\xf8d\\xefng'
b'intensity cdng'
b'intensity c\\N{LATIN SMALL LETTER O WITH STROKE}d\\N{LATIN SMALL LETTER I WITH DIAERESIS}ng'
b'intensity c?d?ng'
b'intensity c&#248;d&#239;ng'

# Check if the string ends with 'coding'

text = "intensity coding"
result = text.endswith("coding")
print(result)  # Output: True

# Check if the string ends with 'Intensity'
result = text.endswith("Intensity")
print(result)  # Output: False

# Check if a substring from position 5 to 15 ends with 'sity'
result = text.endswith("sity", 5, 15)
print(result)  # Output: False

True
False
False

# Original string with tab characters
text = "i\tn\tt\te\tn\ts\ti\tt\ty"

print(text) # Output:
print(text.expandtabs())
print(text.expandtabs(2))
print(text.expandtabs(4))
print(text.expandtabs(10))

i	n	t	e	n	s	i	t	y
i       n       t       e       n       s       i       t       y
i n t e n s i t y
i   n   t   e   n   s   i   t   y
i         n         t         e         n         s         i         t         y

# Original string
text = "intensity coding"

# Find the first occurrence of "coding"
result = text.find("coding")
print(result)  # Output: 10

# Find the first occurrence of "i"
result = text.find("i")
print(result)  # Output: 0

# Find "i" within a range (start at index 5, end at 10)
result = text.find("i", 5, 10)
print(result)  # Output: 6

# If the substring is not found, it returns -1
result = text.find("python")
print(result)  # Output: -1

10
0
6
-1

# Original string
text = "Welcome to {}!"

# Using format() with an empty placeholder
formatted_text = text.format("intensity coding")
print(formatted_text)  # Output: Welcome to intensity coding!

# Using numbered placeholders
formatted_text = "This is {0}, and it is {1}.".format("intensity coding", "awesome")
print(formatted_text)  # Output: This is intensity coding, and it is awesome.

# Using named placeholders
formatted_text = "Welcome to {topic}!".format(topic="intensity coding")
print(formatted_text)  # Output: Welcome to intensity coding!

# Formatting numbers with two decimal places
price = 49
formatted_text = "The price is {:.2f} dollars.".format(price)
print(formatted_text)  # Output: The price is 49.99 dollars.

# Right-align text within a width of 20
formatted_text = "Title: {:>20}".format("intensity coding")
print(formatted_text)  # Output: Title:     intensity coding

# Binary representation of a number
formatted_text = "The binary version of {0} is {0:b}".format(5)
print(formatted_text)  # Output: The binary version of 5 is 101

# Percentage format
formatted_text = "Completion: {:.0%}".format(0.75)
print(formatted_text)  # Output: Completion: 75%

Welcome to intensity coding!
This is intensity coding, and it is awesome.
Welcome to intensity coding!
The price is 49.00 dollars.
Title:     intensity coding
The binary version of 5 is 101
Completion: 75%

# Using format_map() with a dictionary
data = {"topic": "intensity coding", "type": "learning"}
formatted_text = "Welcome to {topic}, a {type} platform!".format_map(data)
print(formatted_text)  # Output: Welcome to intensity coding, a learning platform!

# Using format_map() with a number
data = {"price": 49.99}
formatted_text = "The price is {price:.3f} dollars.".format_map(data)
print(formatted_text)  # Output: The price is 49.99 dollars.

# Handling missing keys (raises KeyError)
data = {"topic": "intensity coding"}
#formatted_text = "Welcome to {topic}, a {type} platform!".format_map(data)
#print(formatted_text)  # Raises KeyError: 'type'

Welcome to intensity coding, a learning platform!
The price is 49.990 dollars.

# Finding the index of a substring
text = "intensity coding"
result = text.index("coding")
print(result)  # Output: 10

# Finding the first occurrence of a character
result = text.index("i")
print(result)  # Output: 0

# Searching within a specific range
result = text.index("i", 2, 12)
print(result)  # Output: 2

# Handling a missing substring (raises ValueError)
# result = text.index("python")  # Raises ValueError: substring not found

10
0
6

# String with only letters and numbers
text = "intensity123"
result = text.isalnum()
print(result)  # Output: True

# String with spaces (not alphanumeric)
text = "intensity 123"
result = text.isalnum()
print(result)  # Output: False

# String with special characters (not alphanumeric)
text = "intensity@123"
result = text.isalnum()
print(result)  # Output: False

# Empty string check
text = ""
result = text.isalnum()
print(result)  # Output: False

True
False
False
False

# String with only letters
text = "intensity"
result = text.isalpha()
print(result)  # Output: True

# String with numbers (not alphabetic)
text = "intensity123"
result = text.isalpha()
print(result)  # Output: False

# String with spaces (not alphabetic)
text = "intensity coding"
result = text.isalpha()
print(result)  # Output: False

# String with special characters (not alphabetic)
text = "intensity!"
result = text.isalpha()
print(result)  # Output: False

# Empty string check
text = ""
result = text.isalpha()
print(result)  # Output: False

True
False
False
False
False

# String with only ASCII characters
text = "intensity123"
result = text.isascii()
print(result)  # Output: True

# String with spaces (ASCII characters are allowed)
text = "intensity coding"
result = text.isascii()
print(result)  # Output: True

# String with an emoji (non-ASCII)
text = "intensity🔥"
result = text.isascii()
print(result)  # Output: False

# String with Unicode characters (non-ASCII)
text = "intensityΩ"
result = text.isascii()
print(result)  # Output: False

# Empty string check
text = ""
result = text.isascii()
print(result)  # Output: True

True
True
False
False
True

# String with only decimal digits
text = "123456"
result = text.isdecimal()
print(result)  # Output: True

# String with a non-decimal character
text = "1234a"
result = text.isdecimal()
print(result)  # Output: False

# Unicode decimal characters
a = "\u0030"  # Unicode for '0
result = a.isdecimal()
print(result)  # Output: True

True
False
True

# String with only digits
text = "50800"
result = text.isdigit()
print(result)  # Output: True

# Unicode digit characters
a = "\u0030"  # Unicode for '0'
b = "\u00B2"  # Unicode for '²' (superscript 2)
print(a.isdigit())  # Output: True
print(b.isdigit())  # Output: True

# String with a non-digit character
text = "123a"
print(text.isdigit())  # Output: False

True
True
True
False

# Check if all characters are lowercase
text = "intensity coding"
result = text.islower()
print(result)  # Output: True

# String contains an uppercase letter
text = "Intensity coding"
result = text.islower()
print(result)  # Output: False

# String with numbers and symbols
text = "hello 123!"
result = text.islower()
print(result)  # Output: True

# String with mixed case letters
text = "mynameisPeter"
result = text.islower()
print(result)  # Output: False

True
False
True
False

# Check if a string contains only numeric characters
text = "565543"
result = text.isnumeric()
print(result)  # Output: True

# Using Unicode numeric characters
a = "\u0030"  # Unicode for 0
b = "\u00B2"  # Unicode for ² (superscript 2)
print(a.isnumeric())  # Output: True
print(b.isnumeric())  # Output: True

# String with non-numeric characters
c = "10km2"
d = "-1"
e = "1.5"
print(c.isnumeric())  # Output: False (contains 'km')
print(d.isnumeric())  # Output: False (contains '-')
print(e.isnumeric())  # Output: False (contains '.')

True
True
True
False
False
False

# String with only printable characters
text = "Intensity Coding"
result = text.isprintable()
print(result)  # Output: True

# String containing a newline character
text = "Intensity\nCoding"
result = text.isprintable()
print(result)  # Output: False

True
False

# String with only spaces
text = "     "
result = text.isspace()
print(result)  # Output: True

# String containing non-whitespace characters
text = "Intensity Coding"
result = text.isspace()
print(result)  # Output: False

# String with spaces and a tab
text = "    \t   "
result = text.isspace()
print(result)  # Output: True

# String with spaces and a newline
text = "   \n   "
result = text.isspace()
print(result)  # Output: True

# String containing "Intensity Coding" with spaces
text = "   Intensity Coding   "
result = text.isspace()
print(result)  # Output: False

True
False
True
True
False

# Title case string
text = "Intensity Coding"
result = text.istitle()
print(result)  # Output: True

# Fully uppercase string
text = "INTENSITY CODING"
result = text.istitle()
print(result)  # Output: False

# Single correctly formatted word
text = "Intensity"
result = text.istitle()
print(result)  # Output: True

# String with a number
text = "22 Intensity Coding"
result = text.istitle()
print(result)  # Output: True

# String with special characters
text = "This Is %'!?"
result = text.istitle()
print(result)  # Output: True

# Incorrect title case (one lowercase letter in a word)
text = "Intensity coding"
result = text.istitle()
print(result)  # Output: False

True
False
True
True
True
False

# Fully uppercase string
text = "INTENSITY CODING"
result = text.isupper()
print(result)  # Output: True

# String with mixed case
text = "Intensity Coding"
result = text.isupper()
print(result)  # Output: False

# String with numbers and symbols (still uppercase)
text = "INTENSITY 123!@#"
result = text.isupper()
print(result)  # Output: True

# String with lowercase letters
text = "INTENSITY coding"
result = text.isupper()
print(result)  # Output: False

# String with no letters
text = "1234!@#"
result = text.isupper()
print(result)  # Output: False

True
False
True
False
False

# Joining a list with a space separator
words = ["Intensity", "Coding"]
result = " ".join(words)
print(result)  # Output: Intensity Coding

# Joining a tuple with a hyphen separator
names = ("John", "Peter", "Vicky")
result = "-".join(names)
print(result)  # Output: John-Peter-Vicky

# Joining dictionary keys with a custom separator
info = {"name": "John", "country": "Norway"}
separator = "TEST"
result = separator.join(info)
print(result)  # Output: nameTESTcountry

# Joining characters with no separator
text = ["I", "n", "t", "e", "n", "s", "i", "t", "y"]
result = "".join(text)
print(result)  # Output: Intensity

# Attempting to join a list with non-string elements (causes error)
numbers = [1, 2, 3]
# result = "-".join(numbers)  # TypeError: sequence item 0: expected str instance, int found

Intensity Coding
John-Peter-Vicky
nameTESTcountry
Intensity

# Left align "Intensity" within 20 spaces (default fill character is space)
text = "Intensity"
result = text.ljust(20)
print(result, "Coding")
# Output: "Intensity           Coding"

# Left align using a custom fill character 'O'
text = "Intensity"
result = text.ljust(20, "O")
print(result)
# Output: "IntensityOOOOOOOOOOO"

# When the specified width is smaller than the string length
text = "Intensity"
result = text.ljust(5)
print(result)
# Output: "Intensity" (unchanged)

# Left align with a different fill character
text = "Coding"
result = text.ljust(15, "-")
print(result)
# Output: "Coding---------"

Intensity            Coding
IntensityOOOOOOOOOOO
Intensity
Coding---------

# Convert text to lowercase
text = "Intensity CODING"
result = text.lower()
print(result)
# Output: intensity coding

intensity coding

# Removing leading spaces
text = "     Intensity Coding     "
result = text.lstrip()
print(f"'{result}'")
# Output: 'Intensity Coding     '

# Removing specified leading characters
text = ",,,,,ssaaww.....Intensity Coding"
result = text.lstrip(",.asw")
print(result)
# Output: 'Intensity Coding'

# Removing specific letters
text = "aaaaaAAAaaathis is string example"
result = text.lstrip("aAth")
print(result)
# Output: 'is is string example

'Intensity Coding     '
Intensity Coding
is is string example

# Replacing a single character
text = "Intensity Coding!"
table = str.maketrans("I", "Y")
print(text.translate(table))
# Output: 'Yntensity Coding!'

# Replacing multiple characters
text = "Intensity Coding!"
x = "ICd"
y = "XYz"
table = str.maketrans(x, y)
print(text.translate(table))
# Output: 'Xntensity Yozing!'

# Replacing and removing characters
text = "Intensity Coding!"
x = "ICd"
y = "XYz"
z = "!"
table = str.maketrans(x, y, z)
print(text.translate(table))
# Output: 'Xntensity Yozing'

# Viewing the translation dictionary
print(str.maketrans(x, y, z))
# Output: {73: 88, 67: 89, 100: 122, 33: None}

Yntensity Coding!
Xntensity Yozing!
Xntensity Yozing
{73: 88, 67: 89, 100: 122, 33: None}

# Partitioning a string using a keyword
text = "Intensity Coding is fun!"
result = text.partition("Coding")
print(result)
# Output: ('Intensity ', 'Coding', ' is fun!')

# Partitioning when the keyword is absent
text = "Intensity Coding is fun!"
result = text.partition("Python")
print(result)
# Output: ('Intensity Coding is fun!', '', '')

# Splitting at a space
text = "Intensity Coding is fun!"
result = text.partition(" ")
print(result)
# Output: ('Intensity', ' ', 'Coding is fun!')

# Case-sensitive search
text = "Intensity Coding is fun!"
result = text.partition("coding")
print(result)
# Output: ('Intensity Coding is fun!', '', '')  # "coding" is not the same as "Coding"

('Intensity ', 'Coding', ' is fun!')
('Intensity Coding is fun!', '', '')
('Intensity', ' ', 'Coding is fun!')
('Intensity Coding is fun!', '', '')

# Replace a word in a sentence
text = "Intensity Coding is fun!"
result = text.replace("Coding", "Learning")
print(result)
# Output: "Intensity Learning is fun!"

# Replace all occurrences of a character
text = "Intensity Coding Coding"
result = text.replace("Coding", "AI")
print(result)
# Output: "Intensity AI AI"

# Replace only the first occurrence
text = "Intensity Coding Coding"
result = text.replace("Coding", "AI", 1)
print(result)
# Output: "Intensity AI Coding"

# Case-sensitive replacement
text = "Intensity Coding is different from coding"
result = text.replace("coding", "AI")
print(result)
# Output: "Intensity Coding is different from AI"  # "Coding" remains unchanged

Intensity Learning is fun!
Intensity AI AI
Intensity AI Coding
Intensity Coding is different from AI

# Find the last occurrence of "Coding"
text = "Intensity Coding is part of Coding."
result = text.rfind("Coding")
print(result)
# Output: 28 (last occurrence of "Coding")

# Find the last occurrence of "e"
text = "Hello, welcome to Intensity Coding!"
result = text.rfind("e")
print(result)
# Output: 21 (last occurrence of "e")

# Find "e" within a specific range
text = "Hello, welcome to Intensity Coding!"
result = text.rfind("e", 5, 15)
print(result)
# Output: 13 (last "e" between index 5 and 15)

# If the substring is not found
text = "Intensity Coding"
result = text.rfind("Z")
print(result)
# Output: -1 (not found)

28
21
13
-1

# Find the last occurrence of "Coding"
text = "Intensity Coding is part of Coding."
result = text.rindex("Coding")
print(result)
# Output: 28 (last occurrence of "Coding")

# Find the last occurrence of "e"
text = "Hello, welcome to Intensity Coding!"
result = text.rindex("e")
print(result)
# Output: 21 (last occurrence of "e")

# Find "e" within a specific range
text = "Hello, welcome to Intensity Coding!"
result = text.rindex("e", 5, 15)
print(result)
# Output: 13 (last "e" between index 5 and 15)

# If the substring is not found (Raises an Exception)
text = "Intensity Coding"
#result = text.rindex("Z")  # Raises ValueError
#print(result)
# Output: ValueError: substring not found

28
21
13

# Right align with spaces (default)
text = "Intensity"
result = text.rjust(20)
print(result, "Coding")
# Output: "           Intensity Coding"  (11 spaces on the left)

# Right align with a custom character "O"
text = "Intensity"
result = text.rjust(20, "O")
print(result)
# Output: "OOOOOOOOOOOIntensity"  (11 'O's on the left)

# When the length is smaller than or equal to the original string
text = "IntensityCoding"
result = text.rjust(10)
print(result)
# Output: "IntensityCoding"  (No change since it's already longer than 10)

# Right align with a symbol
text = "Coding"
result = text.rjust(15, "*")
print(result)
# Output: "*********Coding"  (9 '*' on the left)

           Intensity Coding
OOOOOOOOOOOIntensity
IntensityCoding
*********Coding

# Search for the last occurrence of "Coding"
text = "Intensity Coding is part of Coding."
result = text.rpartition("Coding")
print(result)
# Output: ('Intensity Coding is part of ', 'Coding', '.')

# When the searched word is at the beginning
text = "Coding is essential, but Coding takes practice."
result = text.rpartition("Coding")
print(result)
# Output: ('Coding is essential, but ', 'Coding', ' takes practice.')

# If the substring is not found
text = "Intensity Coding"
result = text.rpartition("Python")
print(result)
# Output: ('', '', 'Intensity Coding')

# Using rpartition() to extract filename from a path
path = "/home/user/documents/Intensity_Coding.txt"
result = path.rpartition("/")
print(result)
# Output: ('/home/user/documents', '/', 'Intensity_Coding.txt')

('Intensity Coding is part of ', 'Coding', '.')
('Coding is essential, but ', 'Coding', ' takes practice.')
('', '', 'Intensity Coding')
('/home/user/documents', '/', 'Intensity_Coding.txt')

# Basic rsplit() without maxsplit (same as split())
txt = "Intensity, Coding, AI"
result = txt.rsplit(", ")
print(result)
# Output: ['Intensity', 'Coding', 'AI']

# Using maxsplit = 1, splits only once from the right
txt = "Intensity, Coding, AI"
result = txt.rsplit(", ", 1)
print(result)
# Output: ['Intensity, Coding', 'AI']

# Splitting a file path to extract filename
path = "/home/user/documents/report.pdf"
result = path.rsplit("/", 1)
print(result)
# Output: ['/home/user/documents', 'report.pdf']

# Extracting domain name from an email
email = "Intensity.coding@example.com"
result = email.rsplit("@", 1)
print(result)
# Output: ['Intensity.coding', 'example.com']

# Handling multiple spaces
txt = "  Hello   World   Python  "
result = txt.rsplit()
print(result)
# Output: ['Hello', 'World', 'Python']  (default separator is whitespace)

['Intensity', 'Coding', 'AI']
['Intensity, Coding', 'AI']
['/home/user/documents', 'report.pdf']
['Intensity.coding', 'example.com']
['Hello', 'World', 'Python']

# Removing trailing spaces
txt = "     intensity coding     "
result = txt.rstrip()
print("of all topics,", result, "is my favorite")
# Output: "of all topics,      intensity coding is my favorite"

# Removing specific trailing characters
txt = "intensity coding,,,,,ssqqqww....."
result = txt.rstrip(",.qsw")
print(result)
# Output: "intensity coding"

# Using rstrip() to clean up log data
log = "intensity coding!!!"
cleaned_log = log.rstrip("!")
print(cleaned_log)
# Output: "intensity coding"

# Handling newline characters
txt = "intensity coding\n\n\n"
result = txt.rstrip("\n")
print(result)
# Output: "intensity coding"

# Removing trailing dots from a filename
filename = "intensity_coding.md..."
cleaned_filename = filename.rstrip(".")
print(cleaned_filename)
# Output: "intensity_coding.md"

of all topics,      intensity coding is my favorite
intensity coding
intensity coding
intensity coding
intensity_coding.md

# Default behavior (splitting on whitespace)
txt = "Intensity Coding is powerful"
result = txt.split()
print(result)
# Output: ['Intensity', 'Coding', 'is', 'powerful']

# Splitting using a comma as the separator
txt = "apple, banana, cherry"
result = txt.split(", ")
print(result)
# Output: ['apple', 'banana', 'cherry']

# Using maxsplit to limit the number of splits
txt = "apple#banana#cherry#orange"
result = txt.split("#", 2)
print(result)
# Output: ['apple', 'banana', 'cherry#orange']

# Handling multiple spaces
txt = "  Intensity    Coding   is  fun  "
result = txt.split()
print(result)
# Output: ['Intensity', 'Coding', 'is', 'fun']

['Intensity', 'Coding', 'is', 'powerful']
['apple', 'banana', 'cherry']
['apple', 'banana', 'cherry#orange']
['Intensity', 'Coding', 'is', 'fun']

# Basic usage (default behavior)
txt = "Thank you for the music\nWelcome to the jungle"
result = txt.splitlines()
print(result)
# Output: ['Thank you for the music', 'Welcome to the jungle']

# Keeping line breaks
txt = "Thank you for the music\nWelcome to the jungle"
result = txt.splitlines(True)
print(result)
# Output: ['Thank you for the music\n', 'Welcome to the jungle']

# Handling different line breaks
txt = "Line1\rLine2\nLine3\r\nLine4"
result = txt.splitlines()
print(result)
# Output: ['Line1', 'Line2', 'Line3', 'Line4']

# Using splitlines() on a multiline string
txt = """Intensity Coding
is powerful
and useful"""
result = txt.splitlines()
print(result)
# Output: ['Intensity Coding', 'is powerful', 'and useful']

['Thank you for the music', 'Welcome to the jungle']
['Thank you for the music\n', 'Welcome to the jungle']
['Line1', 'Line2', 'Line3', 'Line4']
['Intensity Coding', 'is powerful', 'and useful']

# Basic usage
txt = "Intensity Coding is powerful"
result = txt.startswith("Intensity")
print(result)
# Output: True

# Case-sensitive check
txt = "Intensity Coding"
result = txt.startswith("intensity")
print(result)
# Output: False

# Checking with a specific range
txt = "Hello, welcome to Intensity Coding!"
result = txt.startswith("welcome", 7, 20)
print(result)
# Output: True

# Checking multiple prefixes using tuple
txt = "Machine Learning is fascinating"
result = txt.startswith(("Machine", "Deep", "AI"))
print(result)
# Output: True

# Using startswith() to filter strings in a list
sentences = ["AI is evolving", "Machine Learning is key", "Deep Learning is powerful"]
filtered = [s for s in sentences if s.startswith("Machine")]
print(filtered)
# Output: ['Machine Learning is key']

True
False
True
True
['Machine Learning is key']

# Removing leading and trailing spaces
txt = "     Intensity Coding     "
result = txt.strip()
print("of all topics", result, "is my favorite")
# Output: "of all topics Intensity Coding is my favorite"

# Removing specific characters from both ends
txt = ",,,,,rrttgg.....Intensity Coding....rrr"
result = txt.strip(",.grt")
print(result)
# Output: "Intensity Coding"

# Using strip() to clean up filenames
filename = "###report.pdf###"
cleaned_filename = filename.strip("#")
print(cleaned_filename)
# Output: "report.pdf"

# Removing newline characters
txt = "\n\nIntensity Coding is awesome!\n\n"
result = txt.strip()
print(result)
# Output: "Intensity Coding is awesome!"

# Handling user input cleanup
user_input = "   Hello, World!   "
cleaned_input = user_input.strip()
print(cleaned_input)
# Output: "Hello, World!"

of all topics Intensity Coding is my favorite
Intensity Codin
report.pdf
Intensity Coding is awesome!
Hello, World!

# Basic usage of swapcase()
txt = "Hello My Name Is PETER"
result = txt.swapcase()
print(result)
# Output: "hELLO mY nAME iS peter"

# Swapping case in a mixed string
txt = "Intensity Coding 123!"
result = txt.swapcase()
print(result)
# Output: "iNTENSITY cODING 123!"

# Handling special characters and spaces
txt = "Python@123 IS Fun!"
result = txt.swapcase()
print(result)
# Output: "pYTHON@123 is fUN!"

# Swapping case in a sentence
txt = "Learning with ChatGPT is Amazing!"
result = txt.swapcase()
print(result)
# Output: "lEARNING WITH cHATgpt IS aMAZING!"

hELLO mY nAME iS peter
iNTENSITY cODING 123!
pYTHON@123 is fUN!
lEARNING WITH cHATgpt IS aMAZING!

# Basic usage of title()
txt = "welcome to my world"
result = txt.title()
print(result)
# Output: "Welcome To My World"

# Title case with numbers
txt = "welcome to my 2nd world"
result = txt.title()
print(result)
# Output: "Welcome To My 2Nd World"

# Handling words with numbers and symbols
txt = "hello b2b2b2 and 3g3g3g"
result = txt.title()
print(result)
# Output: "Hello B2B2B2 And 3G3G3G"

# Title case with mixed characters
txt = "the quick brown fox's jump"
result = txt.title()
print(result)
# Output: "The Quick Brown Fox'S Jump"

Welcome To My World
Welcome To My 2Nd World
Hello B2B2B2 And 3G3G3G
The Quick Brown Fox'S Jump

# Using a dictionary to replace characters
mydict = {105: 111}  # ASCII: 'i' -> 'o'
txt = "intensity coding"
print(txt.translate(mydict))
# Output: "ontensoty codong"

# Using maketrans() to create a mapping table
txt = "intensity coding"
mytable = str.maketrans("ic", "oz")  # 'i' -> 'o', 'c' -> 'z'
print(txt.translate(mytable))
# Output: "ontensoty zodong"

# Replacing multiple characters
txt = "intensity coding"
x = "int"
y = "xyz"
mytable = str.maketrans(x, y)  # 'i'->'x', 'n'->'y', 't'->'z'
print(txt.translate(mytable))
# Output: "xyzeysxzy codxyg"

# Deleting specific characters while replacing
txt = "intensity coding"
x = "ic"
y = "oz"
z = "tyd"  # Characters to delete
mytable = str.maketrans(x, y, z)
print(txt.translate(mytable))
# Output: "onenso zoong"

# Using a dictionary for replacement and deletion
txt = "intensity coding"
mydict = {105: 111,  # 'i' -> 'o'
          110: 120,  # 'n' -> 'x'
          116: None, # Remove 't'
          115: None} # Remove 's'
print(txt.translate(mydict))
# Output: "oxexoy codoxg"

ontensoty codong
ontensoty zodong
xyzeysxzy codxyg
onenso zoong
oxexoy codoxg

# Converting lowercase to uppercase
txt = "intensity coding"
result = txt.upper()
print(result)
# Output: "INTENSITY CODING"

# Uppercase with numbers and symbols
txt = "intensity123! coding?"
result = txt.upper()
print(result)
# Output: "INTENSITY123! CODING?"

# Using upper() in a case-insensitive comparison
user_input = "Intensity Coding"
stored_value = "INTENSITY CODING"

if user_input.upper() == stored_value:
    print("Match found!")
else:
    print("No match.")
# Output: "Match found!"

# Working with multilingual text
txt = "élève naïve café"
result = txt.upper()
print(result)
# Output: "ÉLÈVE NAÏVE CAFÉ"

INTENSITY CODING
INTENSITY123! CODING?
Match found!
ÉLÈVE NAÏVE CAFÉ

# Padding a number stored as a string
txt = "50"
result = txt.zfill(10)
print(result)
# Output: "0000000050"

# Using zfill() with text
txt = "intensity"
result = txt.zfill(15)
print(result)
# Output: "000000intensity"

# zfill() does not trim longer strings
txt = "intensity coding"
result = txt.zfill(10)
print(result)
# Output: "intensity coding" (unchanged, since it's already longer than 10)

# zfill() with negative numbers
txt = "-42"
result = txt.zfill(6)
print(result)
# Output: "-00042" (zeros added after the minus sign)

# Formatting a date
def perfect_date(day, month, year):
   day = day.zfill(2)
   month = month.zfill(2)
   year = year.zfill(4)
   date = day + '/' + month + '/' + year
   print("The perfect date (DD/MM/YYYY) is: " + date)

perfect_date("1", "2", "2025")
# Output: "The perfect date (DD/MM/YYYY) is: 02/06/2022"

0000000050
000000intensity
intensity coding
-00042
The perfect date (DD/MM/YYYY) is: 01/02/2025

Operator	Description	Example
+	Concatenation - Adds values on either side of the operator	a + b will give HelloPython
*	Repetition - Creates new strings, concatenating multiple copies of the same string	a*2 will give HelloHello
[]	Slice - Gives the character from the given index	a[1] will give e
[ : ]	Range Slice - Gives the characters from the given range	a[1:4] will give ell
in	Membership - Returns true if a character exists in the given string	H in a will give 1
not in	Membership - Returns true if a character does not exist in the given string	M not in a will give 1

Escape character	Result
`\'`	Single Quote
`\\`	Backslash
`\n`	New Line
`\r`	Carriage Return
`\t`	Tab
`\b`	Backspace
`\f`	Form Feed
`\ooo`	Octal value
`\xhh`	Hex value

Point	Description
Use Case	The `%` operator is an old method for formatting strings by inserting values into placeholders.
Syntax	`"string with % placeholders" % (values)`
Parameter	Placeholders are represented by `%` followed by a type specifier (e.g., `%s`, `%d`, `%f`).

No.	Point	Description
1	Uses `%` for string formatting	The `%` operator replaces placeholders in a string with actual values.
2	Supports multiple data types	Placeholders like `%s` (string), `%d` (integer), and `%f` (float) can be used.
3	Allows precision control	Floating-point numbers can be formatted using `%a.bf`, where `a` is width and `b` is precision.

Format Symbol	Conversion
%c	character
%s	string conversion via str() prior to formatting
%i	signed decimal integer
%d	signed decimal integer
%u	unsigned decimal integer
%o	octal integer
%x	hexadecimal integer (lowercase letters)
%X	hexadecimal integer (UPPERcase letters)
%e	exponential notation (with lowercase 'e')
%E	exponential notation (with UPPERcase 'E')
%f	floating point real number
%g	the shorter of %f and %e
%G	the shorter of %f and %E

Point	Description
Use Case	The `format()` method is used for flexible and readable string formatting.
Syntax	`"String with {} placeholders".format(values)`
Parameter	Values inside `.format()` replace `{}` placeholders in the string.

No.	Point	Description
1	Uses `{}` as placeholders	Curly braces `{}` define placeholders in a string.
2	Supports index-based and keyword-based insertion	`{0}, {1}` for positional, `{name}` for named placeholders.
3	Allows reusing values	A placeholder can be used multiple times.
4	Supports precision formatting	`{:.2f}` controls floating-point precision.
5	Handles different data types	`d` (integer), `f` (float), `s` (string), `b` (binary), `o` (octal), `x` (hex).

Point	Description
Use Case	`f-strings` provide a concise way to format strings using expressions directly within `{}`.
Syntax	`f"String with {variables} and {expressions}"`
Parameter	Any valid Python expression inside `{}` gets evaluated and inserted into the string.

No.	Point	Description
1	Uses `f""` or `F""` prefix	Marks the string as an f-string.
2	Supports direct variable interpolation	No need for `.format()` or `%` formatting.
3	Allows expressions inside `{}`	Can include calculations, function calls, and conditions.
4	Supports floating-point precision	`{value:.2f}` controls decimal places.
5	Works with lambda expressions	Allows inline function evaluations.

Format Type	Description	Example	Output
`:<`	Left aligns the result within the available space	`"{:<10}".format("text")`	`"text "`
`:>`	Right aligns the result within the available space	`"{:>10}".format("text")`	`" text"`
`:^`	Center aligns the result within the available space	`"{:^10}".format("text")`	`" text "`
`:=`	Places the sign to the leftmost position	`"{:=+6}".format(-42)`	`"- 42"`
`:+`	Use a plus sign for both positive and negative numbers	`"{:+d}".format(42)`	`"+42"`
`:-`	Use a minus sign for negative values only	`"{:-d}".format(-42)`	`"-42"`
`:`	Inserts an extra space before positive numbers	`"{: d}".format(42)`	`" 42"`
`:,`	Uses a comma as a thousand separator	`"{:,}".format(1000000)`	`"1,000,000"`
`:_`	Uses an underscore as a thousand separator	`"{:_}".format(1000000)`	`"1_000_000"`
`:b`	Binary format	`"{:b}".format(42)`	`"101010"`
`:c`	Converts value to corresponding Unicode character	`"{:c}".format(65)`	`"A"`
`:d`	Decimal format	`"{:d}".format(42)`	`"42"`
`:e`	Scientific format, lowercase `e`	`"{:e}".format(42)`	`"4.200000e+01"`
`:E`	Scientific format, uppercase `E`	`"{:E}".format(42)`	`"4.200000E+01"`
`:f`	Fixed point number format	`"{:f}".format(3.14159)`	`"3.141590"`
`:F`	Fixed point number format, uppercase for special cases	`"{:F}".format(float('nan'))`	`"NAN"`
`:g`	General format (compact scientific or decimal)	`"{:g}".format(42.0)`	`"42"`
`:G`	General format (uppercase `E` for scientific notation)	`"{:G}".format(4200000.0)`	`"4.2E+06"`
`:o`	Octal format	`"{:o}".format(42)`	`"52"`
`:x`	Hexadecimal format (lowercase)	`"{:x}".format(42)`	`"2a"`
`:X`	Hexadecimal format (uppercase)	`"{:X}".format(42)`	`"2A"`
`:n`	Number format	`"{:n}".format(1000)`	`"1000"`
`:%`	Percentage format	`"{:.2%}".format(0.75)`	`"75.00%"`

Point	Description
Use Case	`Template` class provides a simplified way to substitute placeholders in strings.
Syntax	`Template("Hello $name!").substitute(name="World")`
Parameter	Uses `$placeholder` syntax for inserting values dynamically.

No.	Point	Description
1	Import from `string` module	`from string import Template` is required.
2	Uses `$variable_name` placeholders	Supports alphanumeric characters and underscores.
3	`$` can be escaped using `$$`	`$$` results in a single `$` in output.
4	`{}` allows additional text after placeholders	`Template("${name}123")` is valid.
5	`.substitute()` requires all placeholders to be provided	Use `.safe_substitute()` to avoid errors.

Point	Description
Use Case	Aligns a string in the center of a given width by padding with spaces (or a specified character).
Syntax	`string.center(width, fillchar)`
Parameters	`width`(Required) The total width of the final string.
	`fillchar` (Optional) The character used for padding (default is space).

No.	Point	Description
1	Centers the string within a specified width	Adds equal padding on both sides.
2	Default padding character is space	A custom character can be used instead.
3	If `width` is smaller than string length	Returns the original string.
4	If extra space is needed for centering	Left padding is given priority.

No.	Method	Description
1	capitalize()	Converts the first letter of the string to uppercase.
2	casefold()	Transforms the string into lowercase, ensuring case insensitivity.
3	center()	Aligns the string at the center with a specified width.
4	count()	Counts occurrences of a particular substring within the string.
5	encode()	Returns an encoded version of the string.
6	endswith()	Checks if the string concludes with a specific substring.
7	expandtabs()	Defines the tab size within the string.
8	find()	Locates a substring and returns its position in the string.
9	format()	Formats specified values within the string.
10	format_map()	Similar to `format()`, but uses a mapping object for formatting.
11	index()	Finds a substring and returns its position; raises an error if not found.
12	isalnum()	Returns `True` if all characters are alphanumeric.
13	isalpha()	Checks if all characters belong to the alphabet.
14	isascii()	Returns `True` if all characters are ASCII characters.
15	isdecimal()	Returns `True` if the string consists of decimal digits.
16	isdigit()	Checks if all characters in the string are digits.
17	isidentifier()	Validates whether the string is a proper Python identifier.
18	islower()	Returns `True` if all letters in the string are lowercase.
19	isnumeric()	Checks if all characters represent numeric values.
20	isprintable()	Returns `True` if all characters are printable.
21	isspace()	Checks if the string consists solely of whitespace characters.
22	istitle()	Returns `True` if the string follows title case conventions.
23	isupper()	Checks if all letters are uppercase.
24	join()	Concatenates elements of an iterable with the string as a separator.
25	ljust()	Left-aligns the string within a specified width.
26	lower()	Converts all characters to lowercase.
27	lstrip()	Removes leading whitespace from the string.
28	maketrans()	Generates a translation table for string replacements.
29	partition()	Splits the string into three parts based on a specified separator.
30	replace()	Substitutes occurrences of a substring with another.
31	rfind()	Finds the last occurrence of a substring in the string.
32	rindex()	Returns the last position of a substring; raises an error if not found.
33	rjust()	Right-aligns the string within a defined width.
34	rpartition()	Similar to `partition()`, but searches from the end of the string.
35	rsplit()	Splits the string into a list using a separator, starting from the right.
36	rstrip()	Removes trailing whitespace from the string.
37	split()	Divides the string into a list based on a separator.
38	splitlines()	Splits the string at line breaks and returns a list.
39	startswith()	Checks if the string starts with a particular substring.
40	strip()	Removes leading and trailing whitespace.
41	swapcase()	Swaps lowercase letters to uppercase and vice versa.
42	title()	Converts the first letter of each word to uppercase.
43	translate()	Returns a modified string based on a translation table.
44	upper()	Converts the string to uppercase.
45	zfill()	Pads the string with leading zeros to match a specified width.

No.	Point	Description
1	No Effect on Non-Alphabets	If the first character is not a letter, the original string remains unchanged.
2	Already Capitalized First Letter	If the first letter is already uppercase, the method returns the string as is.
3	No Modification to Original String	The method does not change the original string but returns a modified copy.
4	Converts Other Uppercase Letters to Lowercase	Only the first character is capitalized, and all other uppercase letters are converted to lowercase.

No.	Point	Description
1	Uses a Specified Fill Character	If a character is provided as `fillchar`, the string is centered with that character as padding.
2	Default Fill Character is Space	If no `fillchar` is specified, spaces are used for padding.
3	Does Not Modify the Original String	If the specified width is less than the string's length, the original string is returned unchanged.
4	Fill Character Must be a Single Character	The method does not accept multi-character strings as `fillchar`; otherwise, a `TypeError` occurs.

No.	Point	Description
1	Substring Parameter is Mandatory	If the substring is not provided, a `TypeError` occurs.
2	Default Search Range	If `start` and `end` parameters are not provided, the entire string is searched.
3	Case-Sensitive Search	The `count()` method performs a case-sensitive search, meaning `"Apple"` and `"apple"` are treated differently.
4	Does Not Modify Original String	The method returns the count but does not alter the original string.

No.	Point	Description
1	Default Encoding is UTF-8	If no encoding is specified, the string is encoded using UTF-8.
2	Handles Encoding Errors	The `errors` parameter provides flexibility in handling encoding failures.
3	Converts String to Bytes	The `encode()` method returns a byte representation of the string.
4	Works with `decode()`	Encoded byte strings can be decoded back using the `decode()` method.

No.	Point	Description
1	Returns Boolean Output	The method returns `True` or `False` based on whether the string ends with the specified value.
2	Allows Search Within a Range	The `start` and `end` parameters define a specific portion of the string to check.
3	Case-Sensitive	The method is case-sensitive, meaning `"Coding."` and `"coding."` are treated differently.
4	Does Not Modify the Original String	The method only checks for a match and does not alter the string.

Parameter	Description
value	Required. The value to check if the string ends with
start	Optional. An Integer specifying at which position to start the search
end	Optional. An Integer specifying at which position to end the search

No.	Point	Description
1	Default Tab Size	If no `tabsize` is provided, the default size is `8` spaces.
2	Modifies Tabs Only	This method only replaces tab characters (`\t`) with spaces and does not affect other characters.
3	Accepts Any Integer	The `tabsize` can be any integer, including `0`, which removes tab spacing entirely.
4	Does Not Modify Original String	The method returns a new string and does not change the original string.

No.	Point	Description
1	Returns Index or `-1`	If the substring is found, it returns the index of the first occurrence; otherwise, it returns `-1`.
2	Similar to `index()` but Safer	Unlike `index()`, `find()` does not raise an exception if the substring is not found.
3	Can Search Within a Range	The `start` and `end` parameters allow searching within a specific portion of the string.
4	Case-Sensitive	The method is case-sensitive, meaning `"Coding"` and `"coding"` are treated differently.

No.	Point	Description
1	Supports Named, Numbered, and Empty Placeholders	You can use `{name}`, `{0}`, or `{}` as placeholders.
2	Allows Advanced Formatting	You can specify alignment, number formatting, and padding.
3	Works with Different Data Types	Supports integers, floats, strings, and even objects.
4	Does Not Modify Original String	Returns a new formatted string instead of modifying the original one.

No.	Point	Description
1	Uses Dictionary Mapping	Unlike `format()`, it takes a dictionary directly instead of separate arguments.
2	Similar to `format()`	Works like `format()`, but provides a more direct way to use dictionaries.
3	No Key Checking	If a key is missing in the dictionary, it raises a `KeyError`.
4	Does Not Modify Original String	Returns a new formatted string.

Python String

Python String¶

Creating Strings¶

Assign String to a Variable¶

Triple Quotes¶

Strings as Arrays¶

Accessing Individual Characters¶

Negative Indexing¶

Slicing Strings¶

Start index to slice from the beginning:¶

End index to slice to the end :¶

Negative Indexing¶

Concatenation of string¶

Repetition of string¶

Iterating Over Characters¶

String Length¶

max() and min() Method in String¶

Checking if a Character Exists¶

Checking if NOT a Character Exists¶

Special Operators of String¶

Escape Character in String¶

String Formatting in Python¶

With the help of % Operator:¶

Useful Information¶

Explanation¶

Format operator %.¶

With the help of format() string method.¶

Useful Information¶

Explanation¶

With the help of string literals, called f-strings.¶

Useful Information¶

Explanation¶

String Formatting Types¶

With the help of String Template Class¶

Useful Information¶

Explanation¶

With the help of center() string method.¶

Useful Information¶

Explanation¶

Python String Methods¶

1. capitalize()¶

Useful Information¶

2. casefold()¶

3. center()¶

Useful Information¶

4. count()¶

Useful Information¶

5. encode()¶

Useful Information¶

6. endswith()¶

Useful Information¶

7. expandtabs()¶

Useful Information¶

8. find()¶

Useful Information¶

9. format()¶

Useful Information¶

10. format_map()¶

Useful Information¶

11. index()¶

Useful Information¶

12. isalnum()¶

Useful Information¶

13. isalpha()¶

Useful Information¶

14. isascii()¶

Useful Information¶

15. isdecimal()¶

Useful Information¶

16. isdigit()¶

Useful Information¶

17 isidentifier()¶

Useful Information¶

18. islower()¶

Useful Information¶

19. isnumeric()¶

Useful Information¶

20. isprintable()¶

Useful Information¶

21. isspace()¶

No.	Point	Description
1	Raises an Exception if Not Found	Unlike `find()`, it raises a `ValueError` instead of returning `-1`.
2	Case-Sensitive	The search is case-sensitive. `"Code"` and `"code"` are treated differently.
3	Allows Search Within a Range	The `start` and `end` parameters allow searching within a specific section.
4	Does Not Modify the Original String	It only searches for the substring and does not alter the string.

No.	Point	Description
1	Returns a Boolean Output	The method returns `True` if all characters are alphanumeric; otherwise, it returns `False`.
2	No Whitespace or Special Characters	If the string contains spaces, punctuation, or symbols, it returns `False`.
3	Works on Empty Strings	An empty string returns `False` because it has no characters to check.
4	Does Not Modify the Original String	The method only checks the condition and does not alter the string.

No.	Point	Description
1	Returns a Boolean Output	The method returns `True` if all characters are alphabetic; otherwise, it returns `False`.
2	No Digits or Special Characters	If the string contains numbers, spaces, or symbols, it returns `False`.
3	Works on Empty Strings	An empty string returns `False` because it has no characters to check.
4	Does Not Modify the Original String	The method only checks the condition and does not alter the string.

No.	Point	Description
1	Returns a Boolean Output	Returns `True` if all characters are within the ASCII range (0-127); otherwise, it returns `False`.
2	Checks for Non-ASCII Characters	Unicode characters, emojis, and special symbols outside ASCII will return `False`.
3	Works on Empty Strings	An empty string returns `True` since it contains no characters.
4	Does Not Modify the Original String	The method only performs a check and does not alter the string.

No.	Point	Description
1	Returns a Boolean Output	Returns `True` if all characters in the string are decimal numbers (0-9); otherwise, `False`.
2	Unicode Decimal Digits Are Supported	Works with Unicode decimal characters (e.g., Arabic-Indic digits).
3	Does Not Accept Fractions or Subscripts	Characters like `²` (superscript 2) or `⅓` (fraction) return `False`.
4	Does Not Allow Negative Numbers	Strings containing `-` or `.` are not considered decimal numbers.
5	Works on Empty Strings	An empty string returns `False`.

No.	Point	Description
1	Returns a Boolean Output	Returns `True` if all characters in the string are digits (0-9); otherwise, `False`.
2	Recognizes Unicode Digits	Accepts Unicode digit characters like `²` (superscript 2).
3	Does Not Allow Decimal Points	Numbers containing `.` (e.g., `"10.5"`) return `False`.
4	Negative Numbers Are Not Considered Digits	Strings with `-` are not valid digit-only strings.
5	Empty Strings Return `False`	An empty string will return `False`.

No.	Point	Description
1	Valid Identifier Rules	Identifiers must only contain letters (`a-z`, `A-Z`), digits (`0-9`), and underscores (`_`).
2	Cannot Start with a Number	Identifiers cannot begin with a digit.
3	No Spaces Allowed	Identifiers cannot contain spaces.
4	Reserved Keywords Not Checked	It does not check whether a word is a reserved Python keyword.
5	Case-Sensitive	Python identifiers are case-sensitive.

Point	Description
Use Case	The `islower()` method checks whether all alphabetic characters in a string are lowercase. It returns `True` if all letters are lowercase; otherwise, it returns `False`.
Syntax	`string.islower()`
Parameter	No parameters.

No.	Point	Description
1	Returns Boolean Output	The method returns `True` if all alphabetic characters are lowercase; otherwise, it returns `False`.
2	Ignores Non-Alphabet Characters	Numbers, symbols, and spaces do not affect the result. Only alphabetic characters are checked.
3	Case-Sensitive	If there is at least one uppercase letter, the method returns `False`.
4	Does Not Modify the Original String	The method only checks the case of the string; it does not alter it.

Point	Description
Use Case	The `isnumeric()` method checks whether all characters in a string are numeric (0-9, Unicode numeric characters, and fractions). It returns `True` if all characters are numeric; otherwise, it returns `False`.
Syntax	`string.isnumeric()`
Parameter	No parameters.