Strings in Python

● Strings can be defined as a contiguous sequence of symbols or characters.

● In Python Strings are denoted by single, double quotes.

print('spam eggs')# single quotes

print('doesn\'t')# use \' to escape the single
quote...
print("doesn't")# ...or use double quotes instead
print('"Yes," they said.')
print("\"Yes,\" they said.")
print('"Isn\'t," they said.')

Output
spam eggs
doesn't
doesn't
"Yes," they said.
"Yes," they said.
"Isn't," they said.

In the above example, backslash (\) is used as an escape sequence. An

escape sequence is nothing but a special character that has a specific
function. As shown above, backslash (\) is used to escape the quote.

Creating and Initialising Strings

We can inialise a string in the following ways:

● Literal/Constant
strLiteral='spam eggs'
print(strLiteral)
● Using input() method to take input from user
​
strInput=input()
print(strInput)#hi gets printed

Empty String
word =’’
or
word=””
or
word=str()

Indexing

Strings can be indexed (subscripted), with the first character having index
0. There is no separate character type; a character is simply a string of size
one:

word ='Python'
print(word[0])# character in position 0 output P
print(word[5])# character in position 5 output n

Indices may also be negative numbers, to start counting from the right:

word ='Python'
print(word[-1])# last character n
print(word[-2])# second-last character o
print(word[-6]) P
Python Strings are Immutable

Python strings cannot be changed — they are immutable. Therefore,

assigning to an indexed position in the string results in an error:

word ='Python'
word[0]='J'
TypeError: 'str' object does not support item
assignment

Traversing a string

Traversing a string means accessing all the elements of the string one after
the other by using the subscript. A string can be traversed using a ‘for’ loop
or a ‘while’ loop.

Word =’Python’
​
# Traversal using for loop
for i in word:
print(i)
​
Output:
P
y
t
h
o
n

# Traversal using for loop to access index And

character
for i in range(0,len(word):
print(i,’ – ‘,word[i])
​
Output:
0 - P
1 - y
2 - t
3 - h
4 - o
5 - n

​
# Traversal using while loop- can access index
and character both
i =0
while i <len(word):
print( word[i])
i = i +1
​
P
y
t
h
o
n
Multiline Strings/Docstrings
To output the string on multiple lines

To initialize the string on multiple lines.output will be on same line

Or – use ‘’ or “ “ for the same

Operations on String

Concatenation (+)
Strings can be concatenated (glued together) with the + operator. Both the
operands should be of string datatype else it results in an error

word ='uni'+'form' output: uniform

print( word)

num=’12’+’5’ output: 125

print(num)
​
# Concatenating an integer and a string leads to
an error
word ='un'+3
print( word)
​
TypeError: can only concatenate str (not "int")
to str

Repetition/Replication (*)

Strings can be repeated with the * operator where one operand is the string
and the other operand is an integer:

word =3*'Python' output: PythonPythonPython

print(word)
word = int(3.5)*’abc’ output: abcabcabc
print(word)

Membership ([not] in)

The in operator returns the boolean value True if the string contains the
given character or the sequence of characters and vice-versa for the case
of not in operator.

word ='crossing farewell'

​
# Usage of in
In='fare' in word
print(In) Output:True
​
 # Usage of not in
NotIn='Fare' not in word Output:True

Slicing (str[m:n])

● Slicing allows you to obtain a substring

● Slice indices have useful defaults; an omitted first index defaults to zero, an
omitted second index defaults to the length of the string being sliced.

print(word[-len(word):]) #Python
print(word[1:7:2]) #yhn
print(word[::-2]) #nhy
print(word[-6:-1:2]) #Pto

Note:
Slicing rules:
a)if index traverses from LEFT -> RIGHT & STEPVALUE is +ve,it takes
from left to right.If step value is -ve it gives empty string as shown in last 2
examples here
eg) s=’Python’
s[1:5:2] - output: 'yh'
s[:3:1] - output: ‘Pyt’
s[1:5:-1] - ‘’
s[0:5:-2] - ‘’

b)If index traverses from Right – to – Left,the stepvalue is mandatory

& should be negative.If step value is +ve it gives empty string as shown in
last example here
s="python"
s[-1:-6] - ''
s[-1:-6:-1] - 'nohty'
s[-1:-6:-2] - 'nhy'
s[-1:-6:2] - ''

c)If either start or end index is omitted and step value is negative,it
displays the characters in reverse.
Eg1) N="Python Examination"
N[:8:-1] - 'noitanima'
N[8::-1] - 'xE nohtyP'
N[:8:-2] - 'niaia'
N[8::-2] - 'x otP'

d)If the index that is not in range is given in slicing,it does not
generate an error.It gives an EMPTY STRING
s=”Python”
s[100:45:-1] - ‘’
s[10:7] - ‘’
s[7:12] - ‘’

String methods & built in functions

1)len()
Returns the length of the string:

word ='Python'
print(len(word))
6
2)string.capitalize(word)
Return a copy of word with only its first character capitalized and the
remaining characters changed to lowercase.

word ='liGHT battlefield'

print(word.capitalize())
Light battlefield

3)string.find(s, sub[, start[, end]])

Return the lowest index in s where the substring sub is found such that sub
is wholly contained in s[start:end]. Return -1 on failure. Defaults for start
and end and interpretation of negative values is the same as for slices.
4)str.isalnum()
Return true if all characters in the string are alphabets or numeric.Returns
False if there is a space or any other special characters.

5)str.isalpha()
Return true if all characters in the string are alphabetic and there is at least
one character, false otherwise.

word ='apparatus123'
print(word.isalpha())# Returns False as it
contains numeric values
​
word ='apparatus'
print(word.isalpha())# Returns True
word ='apparatus abc'
print(word.isalpha())# Returns False as it has a
space

6)str.isdigit()
Return true if all characters in the string are digits and there is at least one
character, false otherwise.

word ='displace123'
print(word.isdigit()) False
​
word ='123'
print(word.isdigit()) True

7)str.lower()
Returns the exact copy of the string with all the letters in lowercase.
word ='fUnCtIonAl jUnGlE'
print(word.lower())
functional jungle

8)str.islower()
Returns True if the string is in lowercase else returns False.
word ='Python'
print(word.islower()) ---- False
​
word ='python is a prog lang'
print(word.islower()) ----- True

9)str.isupper()
Returns True if the string is in uppercase.
word ='PYTHON'
print(word.isupper()) --- True
​
word ='python'
print(word.isupper()) --- False

10)str.upper()
Returns the exact copy of the string with all letters in uppercase.

word ='fUnCtIonAl jUnGlE'

print(word.upper())
FUNCTIONAL JUNGLE

11)str.isspace()
Returns True if the string contains only whitespace characters.
Str1=’ abc’
print(Str1.isspace()) -------- False
Str2=’ ‘
print (Str2.isspace()) --------- True
word ='Python'
print(word.isspace()) ---------- False

12)str.lstrip([chars])
Return a copy of the string with leading characters removed. The chars
argument is a string specifying the set of characters to be removed. If
omitted or None, the chars argument defaults to removing whitespace. The
chars argument is not a prefix; rather, all combinations of its values are
stripped

word =' spacious '

print(word.lstrip())# spacious
​
word ='www.example.com'
print(word.lstrip('www.'))# example.com

13)str.rstrip([chars])
Return a copy of the string with trailing characters removed. The chars
argument is a string specifying the set of characters to be removed. If
omitted or None, the chars argument defaults to removing whitespace. The
chars argument is not a suffix; rather, all combinations of its values are
stripped:

word =' spacious '

print(word.rstrip()) output:' spacious'

​
word ='mississippi'
print((word.rstrip('ippi')) output:'mississ'

14)strip([chars])- Return a copy of the string with leading and trailing

characters removed.

15)str.istitle()
Return true if the string is a titlecased string and there is at least one
character, for example uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return false
otherwise.
word ='marsh exact'
print(word.istitle()) ---- False
​
word ='Marsh Exact'
print(word.istitle())--------- True

16)str.title() converts the string ti titlecase with the first letter of

each word as uppercase and remaining to lowercase

17)str.replace(old, new[, count])

Return a copy of the string with all occurrences of substring old replaced by
new. If the optional argument count is given, only the first count
occurrences are replaced.

word ='mourning silver mourning silver silver

mourning silver'
​print(word.replace('mourning','happy'))# Replaces
all occurrences of mourning
Output:
happy silver happy silver silver happy silver

print(word.replace('mourning','happy',2))#
Replaces only 2 occurence of mourning
Output:
happy silver happy silver silver mourning silver
18)str.join(iterable)

Returns a string in which the string elements have been joined by a

separator.

words =['Jan','Feb','Mar']# List containing three

strings
op ='&'
​
print(op.join(words))
‘Jan&Feb&Mar’

19)str.swapcase()

Return a copy of the string with uppercase characters converted to

lowercase and vice versa.
word ='fUnCtIonAljUnGlE'
print(word.swapcase())
FuNcTiONaLJuNgLe
20)str.partition(sep)

21)str.split([sep[, maxsplit]])
The function splits the string into substrings using the separator. The
second argument is optional and its default value is zero. If an integer value
N is given for the second argument, the string is split in N+1 strings.

word ='linear$pit$syndrome$cottage$fitness'
​print(word.split('$',3))

Output:
['linear', 'pit', 'syndrome', 'cottage$fitness']
22)count()-It returns the number of times substring occurs in the
given string.If the start index and end index are not given,it starts
from 0 till the length of the string.

23)index()-It is similar to find() as it also searches the

firstoccurance and returns the lowest index of the substring if it is
found.If it is not found in the given string it raises an Exception
24)startswith() – It returns true if the given string starts with the
specified substring,else returns False

25)endswith() – It returns true if the given string ends with the

specified substring,else returns False

26)ord() 27)chr()
2)
Ans: