Python String Methods

Methods to check the contents of a string

 isalnum()
 isalpha()
 isdecimal()
 isdigit()
 isidentifier()
 islower()
 isnumeric()
 isprintable()
 isspace()
 istitle()
 isupper()
 isalnum() Method
[Link]()
• This method returns TRUE if the string is nonempty and all
characters in it are alphanumeric. Otherwise, it returns
FALSE.
• A character is alphanumeric if it is either a letter [a-z],[A-
Z] or a number[0-9].

str = 'abc123'
x = [Link]()
print(x) # True
 isalnum() Method
[Link]()
str = 'abc-123'
x = [Link]()
print(x) # False

str = '*abc123?'
x = [Link]()
print(x) # False

str = 'abc 123'

x = [Link]()
print(x) # False

str = ''
x = [Link]()
print(x) # False
 isalpha() Method
[Link]()
• This method returns TRUE if the string is nonempty and all
characters in it are alphabetic (a-z or A-Z).
• Otherwise, it returns FALSE.
S = 'abc'
x = [Link]() S = 'abc xyz'
print(x) # True x = [Link]()
print(x) # False
S = '123'
x = [Link]() S = ''
print(x) # False x = [Link]()
print(x) # False
S = 'abc123'
x = [Link]()
print(x) # False
 isdecimal() Method
[Link]()
• This method returns TRUE if the string is nonempty
and all characters in it are decimal characters.
Otherwise, it returns FALSE.
• Decimal characters are those that can be used to form
numbers in base 10 (0-9).
• Unicode decimal character such as U+0660 (Arabic-
Indic Digit Zero) is also considered as a decimal.

S = '123'
x = [Link]()
print(x) # True
 isdecimal() Method
[Link]()
# floating point number
S = '123.456'
x = [Link]()
print(x) # False

# number with thousands separator

S = '1,234,567'
x = [Link]() Unicode character such as U+0660
print(x) # False (Arabic-Indic Digit Zero) is also
considered as a decimal.
# empty string S = '\u0660'
S = '' print(S)
x = [Link]() x = [Link]()
print(x) # False print(x) # True
 isdigit() Method
[Link]()
• This method returns TRUE if the string is nonempty
and all characters in it are digits. Otherwise, it
returns FALSE.
• Unicode characters such as superscript
digits ¹ , ² and ³ are also considered as digits.
S = '123'
x = [Link]()
print(x) # True

# floating point number

S = '123.456'
x = [Link]()
print(x) # False
 isdigit() Method
[Link]()
# number with thousands #Unicode character such as superscript
separator digit ² is considered as a digit.
S = '1,234,567' S='10\u00B2'
x = [Link]() print(S) #10²
print(x) # False x = [Link]()
# empty string print(x) # True
S = ''
x = [Link]() #Special Unicode characters like circled
print(x) # False digits ⑥ are also considered as digits.

S = '\u2465' # Special Unicode ⑥

print(S) # ⑥
x = [Link]() # True
 isnumeric() Method
[Link]()
• This method returns TRUE if the string is nonempty
and all characters in it are numeric characters.
Otherwise, it returns FALSE.
• Numeric characters include digit characters, and all
characters that have the Unicode numeric value
property.
• e.g. ² (U+00b2, Superscript Two), ⅕ (U+2155, Vulgar
Fraction One Fifth)
 isnumeric() Method
[Link]()
# empty string
S = '123' S = ''
x = [Link]() x = [Link]()
print(x) # True print(x) # False
# floating point number
S = '123.456' S = '\u00b2'
x = [Link]() print(S) #²
print(x) # False x = [Link]()
# number with thousands print(x) # True
separator
S = '1,234,567' S = '\u2153'
x = [Link]() print(S) #⅓
print(x) # False x = [Link]()
print(x) # True
 isdecimal() vs isdigit() vs isnumeric()
• Is 42 a decimal or digit or numeric number?
print('42'.isdecimal()) # True
print('42'.isdigit()) # True
print('42'.isnumeric()) # True
 isdecimal() vs isdigit() vs isnumeric()
• Is ² (Superscript Two) a decimal or digit or numeric
number?
print('\u00b2'.isdecimal()) # False
print('\u00b2'.isdigit()) # True
print('\u00b2'.isnumeric()) # True
• s ⅓ (Vulgar Fraction One Third) a decimal or digit or
numeric number?
print('\u2153'.isdecimal()) # False
print('\u2153'.isdigit()) # False
print('\u2153'.isnumeric()) # True
 isdecimal() vs isdigit() vs isnumeric()
• isdecimal() method supports only Decimal
Numbers.
• isdigit() method supports Decimals,
Subscripts, Superscripts.
• isnumeric() method supports Digits, Vulgar
Fractions, Subscripts, Superscripts, Roman
Numerals, Currency Numerators.
 islower() Method
[Link]()
• This method doesn't take any parameters.
• This method returns:
• True if all alphabets that exist in the string are
lowercase alphabets.
• False if the string contains at least one uppercase
alphabet.
S = 'abcd'
x = [Link]()
print(x) # True
 islower() Method
[Link]()
#The string doesn’t contain at least one cased character.
S = '123$@%'
x = [Link]()
print(x) # False

#The string contain at least one cased character.

S = 'a123$@%'
x = [Link]()
print(x) # True

#The string contains at least one uppercase alphabet.

S = 'abcdE'
x = [Link]()
print(x) # False
 isupper() Method
[Link]()
• This method doesn't take any parameters.
• Thismethod returns:
– True if all characters in a string are uppercase
characters
– False if any characters in a string are lowercase
characters
S = 'ABCD'
x = [Link]()
print(x) # True
 isupper() Method
[Link]()
#The string doesn’t contain at least one cased character.

S = '123$@%'
x = [Link]()
print(x) # False

#The string contain at least one cased character.

S = 'A123$@%'
x = [Link]()
print(x) # True

#The string contains at least one lowercase alphabet.

S = 'ABCDe'
x = [Link]()
print(x) # False
 isprintable() Method
[Link]()
• This method returns TRUE if the string is empty or all characters in it
are printable.
• Characters that occupies printing space on the screen are known as
printable characters.
• For example:
• letters and symbols
• digits
• punctuation
• Whitespace
• It returns FALSE if the string contains at least one non-printable
character.
• Carriage return \r ,
• line feed \n
• tab \t are examples of nonprintable characters.
• A simple space character ' ' (0x20, ASCII space) is considered printable.
 isprintable() Method
[Link]()
# Check if all characters in the string are printable
S = 'Hello, World!'
x = [Link]()
print(x) # True

# Line feed \n and tab \t are nonprintable characters

S = '\tHello,\nWorld!'
x = [Link]()
print(x) # False

# Empty string is considered printable

S = ''
x = [Link]()
print(x) # True
 isspace() Method
[Link]()
• This method returns TRUE if the string is nonempty
and all characters in it are whitespace characters.
– Characters that are used for spacing are called whitespace
characters.
– For example: tabs (\t), spaces (‘ ‘), newline(\n), Form feed (\
f), carriage return (\r)
• Otherwise, it returns FALSE
S=' ' S = ' \t \n \r \f '
x = [Link]() x = [Link]()
print(x) # True print(x) # True
S = ' a'
x = [Link]()
print(x) # False
 Unicode Whitespace Characters
Unicode Character Description
U+0020 Space
U+00A0 No-Break Space
U+1680 Ogham Space Mark
U+2000 En Quad
U+2001 Em Quad
U+2002 En Space S = '\u2005 \u2007'
U+2003 Em Space x = [Link]()
U+2004 Three-Per-Em Space print(x) # True
U+2005 Four-Per-Em Space
U+2006 Six-Per-Em Space
U+2007 Figure Space
U+2008 Punctuation Space
U+2009 Thin Space
U+200A Hair Space

U+202F Narrow No-Break Space

Medium Mathematical
U+205F Space
U+3000 Ideographic Space
 isidentifier() Method
[Link]()
• This method returns TRUE if the string is a valid identifier
according to the language definition, and FALSE otherwise.
– A valid identifier can only have alphanumeric characters a-z, A-Z,
0-9 and underscore _ .
– The first character of an identifier cannot be a digit.
– Also, identifier should not match a Python keyword (reserved
identifier). S = 'total-Count'
print([Link]()) # False
S = 'totalCount'
print([Link]()) # True
S = '123totalCount'
print([Link]()) # False
S = 'total_Count'
print([Link]()) # True
S = 'totalCount123'
print([Link]()) # True
S = 'total Count'
S = ''
print([Link]()) # False
print([Link]()) # False
 istitle() Method
[Link]()
• This method returns TRUE if the string is nonempty and a
titlecased string. Otherwise, it returns FALSE.
• Numbers and special characters are ignored.
• In titlecased string each word starts with an uppercase
character and the remaining characters are lowercase.
# titlecase # uppercase
S = 'Hello World' S = 'HELLO, WORLD!'
print([Link]()) # True print([Link]()) # False

# numbers and characters # lowercase

S = '*** Hello, World! 123' S = 'hello, world!'
print([Link]()) # True print([Link]()) # False
# Empty string
S = ''
print([Link]()) # False
Methods to search the contents of a string

 count()
 find()
 index()
 rfind()
 rindex()
 startswith()
 endswith()
 count() Method
[Link](sub,start,end)
• This method searches the substring in the given string and returns
how many times the substring is present in it.
• It also takes optional parameters start and end to specify the
starting and ending positions in the string respectively.
str = 'welcome friends, welcome to MIT'
ct=str .count('welcome')
print("Count=",ct) #Count= 2

str = 'welcome friends, welcome to MIT'

ct=str .count('welcome',7)
print("Count=",ct) #Count= 1

str = 'welcome friends, welcome to MIT'

ct=str .count('welcome',7,15)
print("Count=",ct) #Count= 0
 find() Method
[Link](sub,start,end)
• This method searches for the first occurrence of the
specified substring sub and returns its index.
• If specified substring is not found, it returns -1.
• The optional arguments start and end are used to
limit the search to a particular portion of the string.
• This method should be used only if we need to know
the position of sub.
• To check if sub is a substring or not, use the in
operator:
>>> 'Py' in 'Python' #True
 find() Method
[Link](sub,start,end)
str="Rohit is student at BVM"
i=[Link]('student')
print(i) #10

str="Rohit is student at BVM"

i=[Link]('employee')
print(i) #-1

str="let it be, let it be"

i=[Link]('it',6)
print(i) #15

str="let it be, let it be"

i=[Link]('it',2,14)
print(i) #4
 index() Method
[Link](sub,start,end)

• This method searches for the first occurrence of the

specified substring sub and returns its index.
• If specified substring is not found, it raises
ValueError exception.
• The optional arguments start and end are used to limit
the search to a particular portion of the string.
 index() Method
[Link](sub,start,end)
str="Rohit is student at BVM"
i=[Link]('student')
print(i) #9

str="Rohit is student at BVM" Traceback (most recent call last):

i=[Link]('employee') i=[Link]('employee')
print(i) ValueError: substring not found

str="Rohit is student at BVM"

i=[Link]('is',5,10)
print(i) #6

str="Rohit is student at BVM" Traceback (most recent call last):

i=[Link]('is',10) i=[Link]('is',10)
print(i) ValueError: substring not found
 find() vs index()
• The find() method is identical to the index() method.
• The only difference is that the index() method raises
a ValueError exception, if the substring is not found.

str="Rohit is student at BVM" #-1

i=[Link]('employee')
print(i)

str="Rohit is student at BVM" Traceback (most recent call last):

i=[Link]('employee') …
i=[Link]('employee')
print(i)
ValueError: substring not found
 rfind() Method
[Link](sub,start,end)
• This method searches for the last occurrence of the
specified substring sub and returns its index.
• If specified substring is not found, it returns -1.
• The optional arguments start and end are used to limit
the search to a particular portion of the string.
S = 'Big, Bigger, Biggest' S = 'Big, Bigger, Biggest'
x = [Link]('Big') x = [Link]('Big',2,10)
print(x) # 13 print(x) # 5

S = 'Big, Bigger, Biggest'

x = [Link]('Small')
print(x) # -1
 rindex() Method
[Link](sub,start,end)
• This method searches for the last occurrence of the specified
substring sub and returns its index.
• If specified substring is not found, it
raises ValueError exception.
• The optional arguments start and end are used to limit the
search to a particular portion of the string.
S = 'Big, Bigger, Biggest' S = 'Big, Bigger, Biggest'
x = [Link]('Big') x = [Link]('Small')
print(x) # 13 print(x)
Traceback (most recent call last):
S = 'Big, Bigger, Biggest' …
x = [Link]('Big',2,10) x = [Link]('Small')
print(x) # 5 ValueError: substring not found
 rfind() vs rindex()
• The rfind() method is identical to the rindex() method.
• The only difference is that the rindex() method raises
a ValueError exception, if the substring is not found.

S = 'Big, Bigger, Biggest' S = 'Big, Bigger, Biggest'

x = [Link]('Small') x = [Link]('Small')
print(x) # -1 print(x)
Traceback (most recent call last):
…
x = [Link]('Small')
ValueError: substring not found
 startswith() Method
[Link](prefix,start,end)
• This method returns True if the string starts with the
specified prefix, otherwise returns False.
• we can limit the search by specifying optional
arguments start and end.
• startswith() also accepts a tuple of prefixes to look for

str = 'Rohit is a student of BVM'

x = [Link]('Rohit')
print(x) # True
 startswith() Method
[Link](prefix,start,end)
str = 'Rohit is a student of BVM'
x = [Link]('Rohit')
print(x) # True

str = 'Rohit is a student of BVM'

x = [Link]('is')
print(x) # False

str = 'Rohit is a student of BVM'

x = [Link]('is',7,15)
print(x) # True

str = 'Rohit is a student of BVM'

x = [Link](('Balu','Rohit','Devi'))
print(x) # True
 endswith() Method
[Link](suffix,start,end)
• This method returns True if the string ends with the
specified suffix, otherwise returns False.
• we can limit the search by specifying optional
arguments start and end.
• This method also accepts a tuple of suffixes to look for.

str = 'Rohit is a student of BVM'

x = [Link]('BVM')
print(x) # True
 endswith() Method
[Link](suffix,start,end)
str = 'Rohit is a student of BVM'
x = [Link]('is')
print(x) # False

To limit the search to the substring, specify the strat and

end parameters:
str = 'Rohit is a student of BVM'
x = [Link]('is',2,9)
print(x) # True

Provide Multiple Suffixes to Look for

str = 'Rohit is a student of BVM'
x = [Link](('DAV','BVM','ZION'))
print(x) # True
Methods to replace the contents of a
string
(returns a copy of the string where old substring is
replaced with the new substring. The original string is
unchanged)

 replace()
 replace() Method
[Link](old,new,count)
• This method returns a copy of string with all occurrences
of old substring replaced by new.
• By default, all occurrences of the substring are removed.
• However, we can limit the number of replacements by
specifying optional parameter count.
S = 'Hello, World!' S = 'Long, Longer, Longest'
x = [Link]('World','Universe') x = [Link]('Long','Small', 2)
print(x) # Hello, Universe! print(x) # Small, Smaller, Longest

S = 'Long, Longer, Longest'

x = [Link]('Long','Small')
print(x) # Small, Smaller, Smallest
Methods to remove the contents of a string
The original string is unchanged

 strip()
 rstrip()
 lstrip()
 strip() Method
[Link](chars)
• This method removes whitespace from the beginning
(leading) and end (trailing) of the string by default.
• By adding chars(optional) parameter, we can also specify
the characters we want to strip.
S = ' Hello, World! '
x = [Link]()
print(S) Hello, World!
print(x) Hello, World!

#Newline '\n', tab '\t' and carriage return '\r' are also considered as whitespace
characters.
S = ' \t Hello,World!\n\r ' Hello,World!
x = [Link]()
print(S)
print(x) Hello,World!
 strip() Method
[Link](chars)
Strip Characters
• By adding chars parameter, we can also specify the
character we want to strip.
S = 'aaabaaaa'
x = [Link]('a')
print(x) #b

Strip Multiple Characters

S = '[Link]'
x = [Link]('cmowz.')
print(x) #example
 More About strip() Method

• Characters are removed from both

ends until reaching a string character that is not
contained in the set of characters in chars.
 strip() Method
[Link](chars)

S = 'xxxxSxxxxSxxxx'
x = [Link]('x')
print(x) #SxxxxS

S = '... - Version 3.2 Model-32 ...'

x = [Link]('.- ')
print(x) #Version 3.2 Model-32
 lstrip() Method
[Link](chars)
• This method removes whitespace from the beginning
(leading) of the string by default.
• By adding chars(optional) parameter, we can also specify
the characters we want to strip.
S = ' Hello, World! '
x = [Link]()
print(S) Hello, World!
print(x) Hello, World!
• Newline '\n', tab '\t' and carriage return '\r' are also considered
as whitespace characters.
S = ' \t\n\r Hello, World! '
x = [Link]()
print(S) Hello, World!
print(x) Hello, World!
 lstrip() Method
[Link](chars)
Strip Characters
S = 'aaaaab'
x = [Link]('a')
print(S) #aaaaab
print(x) #b

Strip Multiple Characters

S = '[Link]
x = [Link]('hwtp:/.')
print(x) #[Link]
 More About lstrip() Method

S = 'xxxxSxxxxSxxxx'
x = [Link]('x')
print(x) #SxxxxSxxxx

S = '... - Version 3.2 Model-32'

x = [Link]('.- ')
print(x) #Version 3.2 Model-32
 rstrip() Method
[Link](chars)
• This method removes whitespace from the right end (trailing) of
the string by default.
• By adding chars parameter, we can also specify the characters we
want to strip.
S = ' Hello, World! '
x = [Link]()
print(S) # Hello, World!
print(x) # Hello, World!

S = ' Hello, World! \t\n\r ' # Hello, World!

x = [Link]()
print(S)
print(x) # Hello, World!
 rstrip() Method
[Link](chars)
Strip Characters
• By adding chars parameter, we can also specify the
character we want to strip.
S = 'baaaaa'
x = [Link]('a')
print(x) #b

Strip Multiple Characters

S = '[Link]/wow'
x = [Link]('wo/')
print(x) #[Link]
 More About rstrip() Method

xxxxSxxxxS

S = 'xxxxSxxxxSxxxx'
x = [Link]('x')
print(x)

S = 'Version 3.2 Model-32 - ...'

x = [Link]('.- ')
print(x)
#Version 3.2 Model-32
 Methods to split a string
The original string is unchanged

 partition()
 rpartition()
 split()
 splitness()
 rsplit()
 partition() Method
[Link](separator)
• This method splits the string at the first occurrence of separator, and returns
a tuple containing three items.
– The part before the separator
– The separator itself
– The part after the separator
S = 'Do it now and keep it simple'
x = [Link]('and')
print(x) # ('Do it now ', 'and', ' keep it simple')
#No Match Found: If the separator is not found, the method returns a tuple
containing the string itself, followed by two empty strings.
S = 'Do it now and keep it simple'
x = [Link]('or')
print(x) # ('Do it now and keep it simple', '', '')
#Multiple Matches: If the separator is present multiple times, the method
splits the string at the first occurrence.
S = 'Do it now and keep it simple'
x = [Link]('it')
print(x) # ('Do ', 'it', ' now and keep it simple')
 rpartition() Method
[Link](separator)
• This method splits the string at the last occurrence of separator, and returns
a tuple containing three items.
– The part before the separator
– The separator itself
– The part after the separator
S = 'Do it now and keep it simple'
x = [Link]('and')
print(x) # ('Do it now ', 'and', ' keep it simple')
#No match found: If the separator is not found, the method returns a tuple
containing two empty strings, followed by the string itself.
S = 'Do it now and keep it simple'
x = [Link]('or')
print(x) # ('', '', 'Do it now and keep it simple')
#Multiple Matches : If the separator is present multiple times, the method splits
the string at the last occurrence.
S = 'Do it now and keep it simple'
x = [Link]('it')
print(x) # ('Do it now and keep ', 'it', ' simple')
 split() Method
[Link](separator,maxsplit)
• This method takes maximum of 2 parameters:
– separator (optional)
• This is a delimiter
• The string splits at the specified separator.
• If the separator is not specified, any whitespace (space,
newline etc.) string is a separator.
– maxsplit (optional)
• The maxsplit defines the maximum number of splits
• The default value of maxsplit is -1, meaning, no limit on the
number of splits.
• This method breaks the string at the separator and
returns a list of strings.
 split() Method
[Link](delimiter,maxsplit)
text= 'Earth is beautiful'

# splits at space
print([Link]()) #['Earth', 'is', 'beautiful']
print(text) #Earth is beautiful

grocery = 'Milk,Bread,Butter,Jam'

# splits at ','
print([Link](',')) #['Milk', 'Bread', 'Butter', 'Jam']

# Splitting at ':'
print([Link](':')) #['Milk,Bread,Butter,Jam']
 split() Method
[Link](delimiter,maxsplit)

grocery = 'Milk,Bread,Butter,Jam'
print([Link](',', 2)) #['Milk', 'Bread', 'Butter,Jam']

# maxsplit: 1
print([Link](',', 1)) #['Milk', 'Bread,Butter,Jam']

# maxsplit: 5
print([Link](',', 5)) #['Milk', 'Bread', 'Butter', 'Jam']

# maxsplit: 0
print([Link](',', 0)) #['Milk,Bread,Butter,Jam‘]
 splitlines() Method
[Link](keepends)
• This method splits a string at line breaks and
returns them in a list.
• If the optional keepends argument is specified and
TRUE, line breaks are included in the resulting list.
S = 'First line\nSecond line'
x = [Link]()
print(x) # ['First line', 'Second line']

S = 'First\nSecond\r\nThird\fFourth'
x = [Link]()
print(x) # ['First', 'Second', 'Third', 'Fourth']

S = 'First line\nSecond line'

x = [Link](True)
print(x) # ['First line\n', 'Second line']
 rsplit() Method
[Link](separator,maxsplit)
• This method takes maximum of 2 parameters:
– separator (optional)
• The is a delimiter.
• The method splits string starting from the right at the
specified separator.
• If the separator is not specified, any whitespace (space, newline etc.)
string is a separator.
– maxsplit (optional)
• This defines the maximum number of splits.
• The default value of maxsplit is -1, meaning, no limit on the number of
splits.
• This method breaks the string at the separator starting
from the right and returns a list of strings.
 rsplit() Method
[Link](separator,maxsplit)
S = 'The World is Beautiful' #Limit Splits With Maxsplit
x = [Link]()
print(x) # ['The', 'World', 'is', 'Beautiful'] S = 'The World is Beautiful'
x = [Link](None,1)
#Split on comma print(x) # ['The World is', 'Beautiful']
S = 'red,green,blue'
x = [Link](',') S = 'The World is Beautiful'
print(x) # ['red', 'green', 'blue'] x = [Link](None,2)
print(x) # ['The World', 'is', 'Beautiful']
#Delimiter with multiple characters
S = 'the beginning is the end is the beginning'
x = [Link](' is ')
print(x) # ['the beginning', 'the end', 'the beginning']
 rsplit() vs split()
• If maxsplit is specified, rsplit() counts splits from the
right end, whereas split() counts them from left.
• Otherwise, they both behave exactly the same.

# rsplit()
S = 'The World is Beautiful'
x = [Link](None,1)
print(x) # ['The World is', 'Beautiful']

# split()
S = 'The World is Beautiful'
x = [Link](None,1)
print(x) # ['The', 'World is Beautiful']
 Methods to concatenate multiple strings

 join()
 join() Method
[Link](iterable)
• This method provides a flexible way to concatenate string.
• It concatenates each element of an iterable (such as list,
string and tuple whose items are strings) to the string and
returns the concatenated string.
• The join() method takes an iterable - objects capable of
returning its members one at a time
• If there are any non-string values in iterable, a TypeError
will be raised.
#Join all items in a list with comma
L = ['red', 'green', 'blue']
x = ','.join(L)
print(x) # red,green,blue
 join() Method
[Link](iterable)
#Join list items with space
L = ['The', 'World', 'is', 'Beautiful']
x = ' '.join(L)
print(x) # The World is Beautiful

#Join list items with newline

L = ['First Line', 'Second Line']
x = '\n'.join(L)
print(x)
# First Line
# Second Line

#Join with delimiter containing multiple characters

L = ['the beginning', 'the end', 'the beginning']
x = ' is '.join(L)
print(x) # the beginning is the end is the beginning
 join() on Iterable of Size 1
• join() method is smart enough to insert the delimiter in
between the strings rather than just adding at the end of
every string.
• So, if we pass an iterable of size 1, we won’t see the
delimiter.

L = ['red']
x = ','.join(L)
print(x) # red
 Join a List of Integers
Traceback (most recent call last):
L = [1, 2, 3, 4, 5, 6]
…
x = ','.join(L)
x = ','.join(L)
print(x)
TypeError: sequence item 0: expected str instance, int found

• To avoid such exception, we need to convert each item in a

list to string.
• The list comprehension makes this especially convenient.

L = [1, 2, 3, 4, 5, 6]
x = ','.join(str(val) for val in L)
print(x) # 1,2,3,4,5,6
 String modification methods
The original string is unchanged

 upper()
 lower()
 casefold()
 swapcase()
 capitalize()
 title()
 encode()
 upper() Method
[Link]()
• This method doesn't take any parameters.
• This method returns the uppercased string from the
given string.
• It converts all lowecase characters to uppercase.
• If no lowercase characters exist, it returns the original
string.
S = 'Hello, World!' S = '123 abc $@%'
x = [Link]() x = [Link]()
print(x) # HELLO, WORLD! print(x) # 123 ABC $@%
 lower() Method
[Link]()
• This method doesn't take any parameters.
• This method returns the lowercased string from the given
string.
• It converts all uppercase characters to lowercase.
• If no uppercase characters exist, it returns the original string.
S = 'Hello, World!'
x = [Link]()
print(x) # hello, world!

S = '123 ABC $@%'

x = [Link]()
print(x) # 123 abc $@%
 casefold() Method
[Link]()
• This method returns a casefolded (lowercase but
more aggressive) copy of the string.
• The method does not change the original string.
• Casefolded strings are usually used to ‘normalize‘
text for the purposes of caseless comparison
(especially when we want to take characters of many
different languages into account).
old_str = 'WELCOME to MIT!'
new_str = old_str.casefold()
print("New String:",new_str) #New String: welcome to mit!
print("Old String:",old_str) #Old String: WELCOME to MIT!
 casefold() vs lower()
• Casefolding is similar to lowercasing but more aggressive
because it is intended to remove all case distinctions in a
string.
• For example, the German lowercase letter ‘ß‘ is equivalent
to ‘ss‘.
• Since it is already lowercase, lower() would do nothing to
‘ß‘, but casefold() converts it to ‘ss‘.
casefold() lower()
old_str = 'Das straße' old_str = 'Das straße'
new_str = old_str.casefold() new_str =old_str.lower()
print("Old String:",old_str) print("Old String:",old_str)
print("New String:",new_str) print("New String:",new_str)
Old String: Das straße Old String: Das straße
New String: das strasse New String: das straße
 casefold() vs lower()
• If we are working strictly in the English language, lower
and casefold returns exactly the same results.
• However, if we are trying to normalize text from other
languages that use more than English 26-letter alphabet,
use casefold() to compare the strings for more consistent
results.
firstString = "der Fluß"
secondString = "der Fluss“
if [Link]() == [Link]():
print('The strings are equal.')
else:
print('The strings are not equal.')
#The strings are equal.
 swapcase() Method
[Link]()
• This method doesn't take any parameters.
• This method returns the string where all uppercase
characters are converted to lowercase, and lowercase
characters are converted to uppercase.
S = 'Hello, World!'
x = [Link]()
print(x) # hELLO, wORLD!

#swapcase() method ignores numbers and special characters in a string.

S = '123 abc $@%'
x = [Link]()
print(x) # 123 ABC $@%
 capitalize() Method
[Link]()
• This function doesn't take any parameter.
• This function returns a string with first letter capitalized and all
other characters lowercased.
• It doesn't modify the original string.
S = 'Rohit is A STUDENT.'
x = [Link]()
print(x) #Rohit is a student.
print(S) # Rohit is A STUDENT.

Non-alphabetic First Character:For the string with non-alphabetic first

character, the first character is kept unchanged while the rest is changed to
lowercase.
S = '19 is his ROLL number.'
x = [Link]()
print(x) #19 is his roll number.
print(S) #19 is his ROLL number.
 title() Method
[Link]()
• This method doesn't take any parameters.
• This method returns a copy of the string with first
letter of each word is converted to uppercase and
remaining letters are lowercase.
• The method does not change the original string.

S = 'hello, world!'
x = [Link]()
print(x) # Hello, World!
 Unexpected Behavior of title() Method
• The first letter after every number or special character
(such as Apostrophe) is converted into a upper case
letter.
S = "they're Babu's friends."
S = "c3po is a droid"
x = [Link]()
x = [Link]()
print(x) # They'Re Babu'S Friends.
print(x) # C3Po Is A Droid
• As a workaround for this you can use [Link]()
import string import string
S = "c3po is a droid" S = "they're Babu's friends."
x = [Link](S) x = [Link](S)
print(x) # C3po Is A Droid print(x) # They're Babu's Friends.
[Link](s, sep=None): (It is a Helper functions)
This method split the argument into words using [Link](), capitalize each word
using [Link](), and join the capitalized words using [Link](). If the optional
second argument sep is absent or None, runs of whitespace characters are replaced
by a single space and leading and trailing whitespace are removed, otherwise sep is
used to split and join the words.
 encode() Method
[Link](encoding='UTF-8',errors='strict')
• Since Python 3.0, strings are stored as Unicode, i.e. each
character in the string is represented by a code point.
• So, each string is just a sequence of Unicode code points.
• For efficient storage of these strings, the sequence of
code points are converted into set of bytes. The process
is known as encoding.
• There are various encodings present which treats a string
differently. The popular encodings being utf-8, ascii, etc.
• Using string's encode() method, we can convert
unicoded strings into any encodings supported by
Python. By default, Python uses utf-8 encoding.
 encode() Method
[Link](encoding='UTF-8',errors='strict')
• By default, encode() method doesn't require any parameters.
• It returns utf-8 encoded version of the string. In case of failure, it raises
a UnicodeDecodeError exception.
• However, it takes two parameters:
• encoding - the encoding type a string has to be encoded to
• errors - response when encoding fails. There are six types of error
response
 strict - default response which raises a UnicodeDecodeError exception on failure
 ignore - ignores the unencodable unicode from the result
 replace - replaces the unencodable unicode to a question mark ?
 xmlcharrefreplace - inserts XML character reference instead of unencodable
unicode
 backslashreplace - inserts a \uNNNN espace sequence instead of unencodable
unicode
 namereplace - inserts a \N{...} escape sequence instead of unencodable unicode
Encode the string to UTF-8:
str = 'Das straße'
e = [Link]()
print(e) #b'Das stra\xc3\x9fe'
Encoding with error parameter
str = 'Das straße'
e = [Link](encoding='ascii',errors='backslashreplace')
print(e) # b'Das stra\\xdfe'
e = [Link](encoding='ascii',errors='ignore')
print(e) # b'Das strae'
e = [Link](encoding='ascii',errors='namereplace')
print(e) # b'Das stra\\N{LATIN SMALL LETTER SHARP S}e'
e = [Link](encoding='ascii',errors='replace')
print(e) # b'Das stra?e'
e = [Link](encoding='ascii',errors='xmlcharrefreplace')
print(e) # b'Das straße'
e = [Link](encoding='UTF-8',errors='strict')
print(e) # b'Das stra\xc3\x9fe'
 String formatting methods

 format()
 center()
 ljust()
 rjust()
 zfill()
 expandtabs()
 format() Method
• Python also provides a more advanced and powerful
way to do string processing tasks – string formatting. It
allows us to embed variables inside a string.

str = '{} is {} years old.'.format('Rohit', 13)

print(str) #Rohit is 13 years old.
 center() Method
[Link](width,fillchar)
• This method returns center-aligned string of length width.
• Padding is done using the specified fillchar .
• The fillchar argument is optional. If it's not provided,
space is taken as default argument.
• The original string is returned as it is, if width is less than
or equal to string length.
Alternative Method
old_str = 'WELCOME' old_str = 'WELCOME'
new_str = old_str.center(15, '*') new_str = '{:*^15}'.format(old_str)
print("New String:",new_str) print("New String:",new_str)
print("Old String:",old_str) print("Old String:",old_str)
New String: ****WELCOME****
Old String: WELCOME
 center() Method With Default fillchar

old_str = 'WELCOME'
new_str = old_str.center(15)
print("New String:",new_str) New String: WELCOME
print("Old String:",old_str) Old String: WELCOME

•This method doesn't modify the original string.

 ljust() Method
[Link](width,fillchar)
• Thismethod takes two parameters:
– width - width of the given string.
• If width is less than or equal to the length of the string, original string is returned.
– fillchar (Optional) - character to fill the remaining space of the width
• This method returns the left-justified string within the given minimum width.
• If fillchar is defined, it also fills the remaining space with the defined
character.
Alternate Method
S = 'Left' S = 'Left'
x = [Link](12, '*') Output:
x = '{:*<12}'.format(S)
print(x) Left********
print(x)

S = 'Left'
x = [Link](12)
print(x) #Left
 rjust() Method
[Link](width,fillchar)
• This method takes two parameters:
– width - width of the given string.
• If width is less than or equal to the length of the string, original string is returned.
– fillchar (Optional) - character to fill the remaining space of the width
• This method returns the right-justified string within the given
minimum width.
• If fillchar is defined, it fills the remaining space with the defined
S =character.
'Right' Output S = 'Right'
x = [Link](12) Right x = '{:>12}'.format(S)
print(x) Right print(x)

S = 'Right'
x = [Link](12, '*')
print(x) #*******Right
 zfill() Method
[Link](width)
• This method returns a copy of string left padded with ‘0’
characters to make a string of length width.
• The original string is returned, if width is less than or equal
to string length. Alternate Method
S = '42' S = '42'
x = [Link](6) x = '{:0>6}'.format(S)
print(x) #000042 print(x) #000042
String with Sign Prefix
If the string contains a leading sign + or -, zeros are padded after the
sign character rather than before.
S = '+42' S = '-42'
x = [Link](6) x = [Link](6)
print(x) #+00042 print(x) #-00042
 expandtabs() Method
[Link](tabsize)
• This method replaces each tab character ‘\t‘ in
a string with specified number of spaces (tabsize).
• The default tabsize is 8 (tab stop at every eighth
column). S = 'a\tb\tc'
S1 = 'a\tb\tc'
S2 = 'aaaa\tbbbb\tcccc' print([Link](2))
print([Link]()) print([Link](4))
print([Link]()) print([Link](6))
abc
a b c a b c
aaaa bbbb cccc a b c
 Common String Methods
• Checking the contents of a string:
– isalpha()
– isdigit()
– islower()
– isupper()
• Modifying the contents of a string:
– lower()
– upper()
• Searching the contents of a string:
– find(sub,start,end)
• Replacing the contents of a string
– replace(old,new,count)
• Removing the contents of a string
– strip()
• Splitting a string
– Split(seperator,maxsplit)
• Joining a string (concatenation)
– Join(iterable)
• Formatting a string
– format()