Lists

LIST
 A list is a sequence
 Like a string, a list is a sequence of values.
 In a string, the values are characters;
 In a list, they can be any type. The values in list are called elements or sometimes
items.
 There are several ways to create a new list; the simplest is to enclose the elements
in square brackets ([ and ]):

[10, 20, 30, 40]

['crunchy frog', 'ram bladder', 'lark vomit']
 The first example is a list of four integers. The second is a
list of three strings.
 The elements of a list don’t have to be the same type.
 The following list contains a string, a float, an integer, and
another list:
 ['spam', 2.0, 5, [10, 20]]
 A list within another list is nested.
 A list that contains no elements is called an empty list;
you can create one with empty brackets, [].
>>> cheeses = ['Cheddar', 'Edam', 'Gouda']
>>> numbers = [17, 123]
>>> empty = []
>>> print(cheeses, numbers, empty)
['Cheddar', 'Edam', 'Goden'] [17, 123] []
 LISTS ARE MUTABLE
 The syntax for accessing the elements of a list is the same as for
accessing the characters of a string: the bracket operator.
 The expression inside the brackets specifies the index.
 Remember that the indices start at 0:

>>> print(cheeses[0])
Cheddar
 Unlike strings, lists are mutable because you can change
the order of items in a list or reassign an item in a list.
 When the bracket operator appears on the left side of an
assignment, it identifies the element of the list that will be
assigned.
>>> numbers = [17, 123]
>>> numbers[1] = 5
>>> print(numbers)
[17, 5]
 List can be viewed as relationship between indices and
elements.
 This relationship is called a mapping; each index “maps
to” one of the elements.
List indices work the same way as string indices:
• Any integer expression can be used as an index.
• If you try to read or write an element that does not exist,
you get an IndexError.
• If an index has a negative value, it counts backward from
the end of the list.
 The in operator also works on lists.
>>> animals = [‘cow', ‘lion', ‘elephant']
>>> ‘lion' in animals
True
>>> ‘book' in animals
False
TRAVERSING A LIST
 The most common way to traverse the elements of
a list is with a for loop.
 The syntax is the same as for strings:
for word in animals:
print(word)
 If you want to write or update the elements, you need the indices. A common way
to do that is to combine the functions range and len:

for i in range(len(numbers)):
numbers[i] = numbers[i] * 2
 A for loop over an empty list never executes the body:
for x in empty:
print('This never happens.')
 Although a list can contain another list, the nested list still counts as a
single element. The length of this list is four:
 ['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]
EXAMPLE 1.PY
 Write a Python program to sum all the items in a list.
LI1.PY
def sum_list(items):
sum_numbers = 0
for x in items:
sum_numbers += x
return sum_numbers
print(sum_list([1,2,-8]))
EXAMPLE LI2.PY
Write a Python program to multiply all the
items in a list.
LI2.PY
 def multiply_list(items):
 tot = 1
 for x in items:
 tot *= x
 return tot
 print(multiply_list([1,2,-8]))
EXAMPLE LI3.PY
 Write a Python program to get the largest number from a list.
LI3.PY
 def max_num_in_list( list ):
 max = list[0]
 for a in list:
 if a > max:
 max = a
 return max
 print(max_num_in_list([1, 2, -8, 0]))
EXAMPLE 4.PY
 Write a Python program to get the smallest number
from a list.
LI4.PY
 def smallest_num_in_list( list ):
 min = list[ 0 ]
 for a in list:
 if a < min:
 min = a
 return min
 print(smallest_num_in_list([1, 2, -8, 0]))
EXAMPLE LI5.PY
 Write a Python program to count the number of strings

where the string length is 2 or more and the first and last
character are same from a given list of strings.

Sample List : ['abc', 'xyz', 'aba', '1221']

Expected Result : 2
LI5.PY
 def match_words(words):
 ctr = 0
 for word in words:
 if len(word) > 1 and word[0] == word[-1]:
 ctr += 1
 return ctr

 print(match_words(['abc', 'xyz', 'aba', '1221']))

EXAMPLE LI6.PY
 Write a Python program to check a list is empty or not.
LI6.PY
l = []
if not l:
 print("List is empty")

LIST OPERATIONS
 The + operator concatenates lists:
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b
>>> print(c)
[1, 2, 3, 4, 5, 6]
 Similarly, the * operator repeats a list a given
number of times:
>>> [0] * 4
[0, 0, 0, 0]
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
 The first example repeats four times. The
second example repeats the list three times.
LIST SLICES
 The slice operator also works on lists:
>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3]
['b', 'c']
>>> t[:4]
['a', 'b', 'c', 'd']
>>> t[3:]
['d', 'e', 'f']
 If you omit the first index, the slice starts at the beginning.
 If you omit the second, the slice goes to the end.
 So if you omit both, the slice is a copy of the whole list.
>>> t[:]
['a', 'b', 'c', 'd', 'e', 'f']
 A slice operator on the left side of an assignment can update
multiple elements:
>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3] = ['x', 'y']
>>> print(t)
['a', 'x', 'y', 'd', 'e', 'f']
 LIST METHODS
 Python provides methods that operate on lists. For example,
append adds a new element to the end of a list:
>>> t = ['a', 'b', 'c']
>>> t.append('d')
>>> print(t)
['a', 'b', 'c', 'd']
 Extend takes a list as an argument and appends all of the
elements:
>>> t1 = ['a', 'b', 'c']
>>> t2 = ['d', 'e']
>>> t1.extend(t2)
>>> print(t1)
['a', 'b', 'c', 'd', 'e']
This example leaves t2 unmodified.
 sort arranges the elements of the list from low to high:
>>> t = ['d', 'c', 'e', 'b', 'a']
>>> t.sort()
>>> print(t)
['a', 'b', 'c', 'd', 'e']
 Most list methods are void; they modify the list and return
None.
 If you accidentally write t = t.sort(), you will be disappointed
with the result.
 EXAMPLE 7.PY
 Write a Python function that takes two lists and returns True if

they have at least one common member.

LI7.PY
 def common_data(list1, list2):
 result = False
 for x in list1:
 for y in list2:
 if x == y:
 result = True
 return result
 print(common_data([1,2,3,4,5], [5,6,7,8,9]))
 print(common_data([1,2,3,4,5], [6,7,8,9]))
 DELETING ELEMENTS
 There are several ways to delete elements from a list.
 If you know the index of the element you want, you can use pop:
>>> t = ['a', 'b', 'c']
>>> x = t.pop(1)
>>> print(t)
['a', 'c']
>>> print(x)
b
 pop modifies the list and returns the element that was removed.
 If you don’t provide an index, it deletes and returns the last element.
 If you don’t need the removed value, you can use the
del operator:
>>> t = ['a', 'b', 'c']
>>> del t[1]
>>> print(t)
['a', 'c']
 If you know the element you want to remove (but not the
index), you can use remove:
 >>> t = ['a', 'b', 'c']
 >>> t.remove('b')
 >>> print(t)
 ['a', 'c']
 The return value from remove is None.
 To remove more than one element, you can use del
with a slice index:
 >>> t = ['a', 'b', 'c', 'd', 'e', 'f']
 >>> del t[1:5]
 >>> print(t)
 ['a', 'f']
LISTS AND FUNCTIONS
 There are a number of built-in functions that can be used on lists that allow you
to quickly look through a list without writing your own loops:
>>> nums = [3, 41, 12, 9, 74, 15]
>>> print(len(nums))
6
>>> print(max(nums))
74
>>> print(min(nums))
3
>>> print(sum(nums))
154
>>> print(sum(nums)/len(nums))
25
 The sum() function only works when the list elements are numbers.
 The other functions (max(), len(), etc.) work with lists of strings and other
types that can be comparable.
 We could rewrite an earlier program that computed the average of a list
of numbers entered by the user using a list.
 First, the program to compute an average without a list:
 total = 0
 count = 0
 while (True):
 inp = input('Enter a number: ')
 if inp == 'done': break
 value = float(inp)
 total = total + value
 count = count + 1
 average = total / count
 print('Average:', average)
 We could simply remember each number as the user entered it and use built-in
functions to compute the sum and count at the end.

 numlist = list()

 while (True):

 inp = input('Enter a number: ')

 if inp == 'done': break

 value = float(inp)

 numlist.append(value)

 average = sum(numlist) / len(numlist)

 print('Average:', average)
 LISTS AND STRINGS
 A string is a sequence of characters and a list is a sequence of values, but
a list of characters is not the same as a string.
 To convert from a string to a list of characters, you can use list:

>>> s = 'spam'
>>> t = list(s)
>>> print(t)
['s', 'p', 'a', 'm']
 The list function breaks a string into individual letters.
 If you want to break a string into words, you can use the
split method:
>>> s = 'pining for the fjords'
>>> t = s.split()
>>> print(t)
['pining', 'for', 'the', 'fjords']
>>> print(t[2])
the
 You can call split with an optional argument called a delimiter

that specifies which characters to use as word boundaries. The

following example uses a hyphen as a delimiter:

>>> s = 'spam-spam-spam'
>>> delimiter = '-'
>>> s.split(delimiter)
['spam', 'spam', 'spam']
 join is the inverse of split. It takes a list of strings and
concatenates the elements.
 join is a string method, so you have to invoke it on the delimiter
and pass the list as a parameter:

>>> t = ['pining', 'for', 'the', 'fjords']

>>> delimiter = ' '
>>> delimiter.join(t)
'pining for the fjords'
PARSING LINES
 Often we want to find the “interesting lines” and then parse the line to find some
interesting part of the line.

 What if we wanted to print out the day of the week from those lines that start with
“From”?

 From [email protected] Sat Jan 5 09:14:16 2008

 The split method is very effective when faced with this kind of problem.

 We can write a small program that looks for lines where the line starts with “From”,
split those lines, and then print out the third word in the line:
 fhand = open('mbox-short.txt')
 for line in fhand:
 line = line.rstrip()
 if not line.startswith('From '): continue
 words = line.split()
 print(words[2])
The program produces the following output:
 Sat
 Fri
 Fri
 Fri
 OBJECTS AND VALUES
 If we execute these assignment statements:
a = 'banana'
b = 'banana‘
 we know that a and b both refer to a string, but we don’t know
whether they refer to the same string. There are two possible states:
 In one case, a and b refer to two different objects that have the same value.
 In the second case, they refer to the same object.
 To check whether two variables refer to the same object, you can use the
is operator.

>>> a = 'banana'
>>> b = 'banana'
>>> a is b
True
 In this example, Python only created one string object, and both a and b
refer to it.
 But when you create two lists, you get two objects:
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a is b
False
 In this case we would say that the two lists are equivalent,
because they have the same elements, but not identical, because
they are not the same object.
 If two objects are identical, they are also equivalent, but if they
are equivalent, they are not necessarily identical.
 ALIASING
 If a refers to an object and you assign b = a, then both variables refer to the same object:
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
 The association of a variable with an object is called a reference. In this example, there are two
references to the same object.
 An object with more than one reference has more than one name, so we say that the object is
aliased.
 If the aliased object is mutable, changes made with one alias affect the other:
>>> b[0] = 17
>>> print(a)
[17, 2, 3]
 LIST ARGUMENTS
 When you pass a list to a function, the function gets a reference to the list.
 If the function modifies a list parameter, the caller sees the change.
 For example, delete_head removes the first element from a list:
def delete_head(t):
del t[0]
 Here’s how it is used:
>>> letters = ['a', 'b', 'c']
>>> delete_head(letters)
>>> print(letters)
['b', 'c']
 The parameter t and the variable letters are aliases for the same object.
 It is important to distinguish between operations that modify lists and operations that create
new lists. For example, the append method modifies a list, but the + operator creates a new list:
>>> t1 = [1, 2]
>>> t2 = t1.append(3)
>>> print(t1)
[1, 2, 3]
>>> print(t2)
None

>>> t3 = t1 + [3]
>>> print(t3)
[1, 2, 3]
>>> t2 is t3
False
EXAMPLE 8.PY
 Write a Python program to print a specified list after removing the
specified element.
Sample List :
['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']
Enter Item to delete: Black

Expected Output :
['Red', 'Green', 'White', 'Pink', 'Yellow']
 LI8.PY
 def cdelete(clist,item):
 clist.remove(item)

 clist=['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']
 print('Before deleting:',clist)
 item=input("Enter the Item to remove:")
 if item in clist:
 cdelete(clist,item)
 print('After calling delete:',clist)
 print(clist)
 else:
 print("Item is not in the list")

EXAMPLE 9.PY
 Write a Python program to get a list of words and convert it into a string using

required delimeter.

 Example: [‘India’, ’is’, ’democratic’, ’country’]

 OutPut with space as delimiter: India is democratic country

 OutPut with - as delimiter: India-is-democratic-country

 LI9.PY
 Mylist=[]
 while (True):
 inp = input('Enter List Item: ')
 if inp == 'done': break
 Mylist.append(inp)
 print("Before Adding delimiter:",Mylist)
 delimiter=input("Enter the required delimiter:")
 print("After Adding delimiter:")
 print(delimiter.join(Mylist))
EXAMPLE 10.PY
 Write a python program to Find common items from two
lists.
LI10.PY
 color1 = "Red", "Green", "Orange", "White"
 color2 = "Black", "Green", "White", "Pink"
 print(set(color1) & set(color2))
 EXAMPLE 11.PY
 Write a python program to replace a word in the sentence with a
given word.

 Example: Two roads diverged in the woods, I take the one less
travelled.
 Replace: take->took
 Output: Two roads diverged in the woods, I took the one less
travelled.
 LI11.PY
 sentence="Two roads diverged in the woods, I take the one less travelled."
 print(sentence)

 old_word=input(“Enter word to Sentence:")

 new_word=input("enter the New WORD")

 sentence=sentence.split()
 for i,x in enumerate(sentence):
 if x==old_word:
 sentence[i]=new_word
 sentence=" ".join(sentence)
 print(sentence)
STRINGS
 A string is a sequence of characters. You can access the
characters one at a time with the bracket operator:
>>> fruit = 'banana'
>>> letter = fruit[1]
 The second statement extracts the character at index
position 1 from the fruit variable and assigns it to the letter
variable.
 The expression in brackets is called an index. The index
indicates which character in the sequence you want (hence
the name).
>>> print(letter)
a
 For most people, the first letter of “banana” is b, not a. But in Python, the index is
an offset from the beginning of the string, and the offset of the first letter is zero.
>>> letter = fruit[0]
>>> print(letter)
b
 So b is the 0th letter (“zero-eth”) of “banana”, a is the 1th letter (“one-eth”), and
n is the 2th letter.
 You can use any expression, including variables and operators, as an index, but
the value of the index has to be an integer. Otherwise you get:
>>> letter = fruit[1.5]
TypeError: string indices must be integers
GETTING THE LENGTH OF A
STRING WITHOUT USING FUNCTION

Write a Python program to calculate the length of a string without

using len().
Example 1.py
def string_length(str1):
count = 0
for char in str1:
count += 1
return count
print("Length of the String=",string_length(input("Enter
the string")))
GETTING THE LENGTH OF A
STRING USING LEN FUNCTION
 len is a built-in function that returns the number of characters in a string:

>>> fruit = 'banana'

>>> len(fruit)
6
 To get the last letter of a string, you might be tempted to try something like this:

>>> length = len(fruit)

>>> last = fruit[length]
IndexError: string index out of range
 The reason for the IndexError is that there is no letter in ’banana’ with the index 6. Since we

started counting at zero, the six letters are numbered 0 to 5.

 To get the last character, you have to subtract 1 from length:

>>> last = fruit[length-1]

>>> print(last)
a
 Alternatively, you can use negative indices, which count backward from the end of the string.

The expression fruit[-1] yields the last letter, fruit[-2] yields the second to last, and so on.
 EXAMPLE 2.PY
 Write a Python program to count the character frequency in a
string.
 def char_frequency(str1):
 dict = {}
 for n in str1:
 keys = dict.keys()
 if n in keys:
 dict[n] += 1
 else:
 dict[n] = 1
 return dict
 print(char_frequency(input("Enter the String"))
EXAMPLE 3.PY
 Write a Python program to get a string made of the first 2 and the

last 2 chars from a given a string. If the string length is less than
2, return empty string.
 3.PY
def string_both_ends(str):
if len(str) < 2:
return ‘ '

return str[0:2] + str[-2:]

print(string_both_ends(input("Enter the string:")))

 TRAVERSAL THROUGH A STRING WITH A LOOP
 A lot of computations involve processing a string one character at a time. Often they

start at the beginning, select each character in turn, do something to it, and continue
until the end. This pattern of processing is called a traversal.

 One way to write a traversal is with a while loop:

index = 0
while index < len(fruit):
letter = fruit[index]
print(letter)
index = index + 1
 EXAMPLE: 4.PY
 Write a while loop that starts at the first character in the string and

works its way forward to the last character in the string, printing each
letter on a separate line
 4.PY
 def disp(str):
 index = 0
 while index < len(str):
 letter = str[index]
 print(letter)
 index = index + 1

 s=input("Enter the string")

 disp(s)
 EXAMPLE 5.PY

 Write a while loop that starts at the last character in the string and works its way

backwards to the first character in the string, printing each letter on a separate
line
 5.PY
 def disp(str):
 index = len(str)-1
 while index >= 0:
 letter = str[index]
 print(letter)
 index = index - 1

 s=input("Enter the string")

 disp(s)
 Another way to write a traversal is with a for loop:

for char in fruit:

print(char)
 Each time through the loop, the next character in the string is

assigned to the variable char. The loop continues until no

characters are left.
EXAMPLE 6.PY
 Write a Python program to output a string from a given string where all occurrences

of its first char have been changed to '$', except the first char itself.

Sample String : 'restart'

Expected Result : 'resta$t'

6.PY
 def change_char(str1):
 char = str1[0]
 str1 = str1.replace(char, '$')
 str1 = char + str1[1:]

 return str1

 print(change_char(input('Enter the string:')))

STRING SLICES
 A segment of a string is called a slice. Selecting a slice is similar to selecting a

character:

>>> s = 'Monty Python'

>>> print(s[0:5])

Monty

>>> print(s[6:12])

Python
 The [n : m] operator returns the part of the string from the “n-th” character to the “m-th”

character, including the first but excluding the last.

 If you omit the first index (before the colon), the slice starts at the beginning of the string.

 If you omit the second index, the slice goes to the end of the string:

>>> fruit = 'banana'

>>> fruit[:3]

'ban'

>>> fruit[3:]

'ana'
 If the first index is greater than or equal to the second the result is an empty

string, represented by two quotation marks:

>>> fruit = 'banana'

>>> fruit[3:3]

‘'

 An empty string contains no characters and has length 0, but other than that, it

is the same as any other string.

>>> fruit = 'banana'

>>> fruit[:]

‘banana’
EXAMPLE 7.PY
 Write a Python program to get a single string from two given strings,

separated by a space and swap the first two characters of each string.
Sample String1 : 'abc‘

Sample String2 : 'xyz'

Expected Result : 'xyc abz'

 7.PY
 def chars_mix_up(a, b):
 new_a = b[:2] + a[2:]
 new_b = a[:2] + b[2:]

 return new_a + ' ' + new_b

 string1=input("Enter String1:")
 string2=input("Enter String2:")
 finalstr=chars_mix_up(string1,string2)
 print(finalstr)
STRINGS ARE IMMUTABLE
 Strings are immutable, meaning once assigned it cannot be modified.

>>> greeting = 'Hello, world!'

>>> greeting[0] = 'J'
TypeError: 'str' object does not support item assignment
 The reason for the error is that strings are immutable, which means you can’t change
an existing string. The best you can do is create a new string that is a variation on
the original:
 >>> greeting = 'Hello, world!'
>>> new_greeting = 'J' + greeting[1:]
>>> print(new_greeting)
Jello, world!

 This example concatenates a new first letter onto a slice of greeting. It has no
effect on the original string.
 EXAMPLE: 8.PY
 Write a Python program to add 'ing' at the end of a given string (length should be at

least 3). If the given string already ends with 'ing' then add 'ly' instead. If the string
length of the given string is less than 3, leave it unchanged.

 Sample String : 'abc'

Expected Result : 'abcing'

Sample String : 'string'
Expected Result : 'stringly'
 8.PY
 def add_string(str1):
 length = len(str1)

 if length > 2:
 if str1[-3:] == 'ing':
 str1 += 'ly'
 else:
 str1 += 'ing'

 return str1
 str=input("Enter the string:") #input abc, string
 str=add_string(str)
 print(str)
EXAMPLE: 9.PY

 Write a Python program to find the first appearance of the substring 'not' and 'poor'

from a given string, if ‘not' follows the 'poor', replace the whole 'not'...'poor'
substring with 'good'. Return the resulting string.

Sample String : 'The lyrics is not that poor!'

Expected Result : 'The lyrics is good!'
 def not_poor(str1):
 snot = str1.find('not')
 sbad = str1.find('poor')

 if snot==-1:
 return str1

 if sbad > snot:
 str2 = str1.replace(str1[snot:(sbad+4)], 'good')
 return str2
 else:
 return str1
 print(not_poor(input("Enter the string:"))) #'The lyrics is not that poor!
THE IN OPERATOR
 The word in is a boolean operator that takes two strings and returns True if the first

appears as a substring in the second:

>>> 'a' in 'banana'

True
>>> 'seed' in 'banana'
False
 STRING COMPARISON
 The comparison operators work on strings. To see if two strings are equal:
if word == 'banana':
print('All right, bananas.')
 Other comparison operations are useful for putting words in alphabetical order:
if word < 'banana':
print('Your word,' + word + ', comes before banana.')
elif word > 'banana':
print('Your word,' + word + ', comes after banana.')
else:
print('All right, bananas.')
 Python does not handle uppercase and lowercase letters the same
way that people do.
 All the uppercase letters come before all the lowercase letters, so:
 Your word, Pineapple, comes before banana.
 A common way to address this problem is to convert strings to a
standard format, such as all lowercase, before performing the
comparison.
 Strings are an example of Python objects. An object contains both data (the actual
string itself) and methods, which are effectively functions that are built into the object
and are available to any instance of the object.
 Python has a function called dir which lists the methods available for an object.
 The type function shows the type of an object and the dir function shows the
available methods.
>>> stuff = 'Hello world'
>>> type(stuff)
<class 'str'>
>>> dir(stuff)
['capitalize', 'casefold', 'center', 'count', 'encode',
'endswith' , 'expandtabs', 'find', 'format', 'format_map',
'index' , 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
'isidentifier' , 'islower', 'isnumeric', 'isprintable',
'isspace' , 'istitle', 'isupper', 'join', 'ljust', 'lower',
'lstrip' , 'maketrans', 'partition', 'replace', 'rfind',
'rindex' , 'rjust', 'rpartition', 'rsplit', 'rstrip',
'split' , 'splitlines', 'startswith', 'strip', 'swapcase',
'title' , 'translate', 'upper', 'zfill']
>>> help(str.capitalize)
Help on method_descriptor:
capitalize(...)
S.capitalize() -> str
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
>>>
 Write a Python script that takes input from the user and displays that input back in
upper and lower cases
 user_input = input("Enter the String in Lower Case:")
 print("String in Upper Case:", user_input.upper())
 print("String in Lower Case:", user_input.lower())
>>> word = 'banana‘
 The find method can find substrings as well as characters:
>>> word.find('na')
2
 It can take as a second argument the index where it should start:
>>> word.find('na', 3)
4
 One common task is to remove white space (spaces, tabs, or newlines)
from the beginning and end of a string using the strip method:
>>> line = ' Here we go '
>>> line.strip()
'Here we go'
 Some methods such as startswith return boolean values.
>>> line = 'Have a nice day'
>>> line.startswith('Have')
True
>>> line.startswith('h')
False
 startswith requires case to match, so sometimes we take a line and map
it all to lowercase before we do any checking using the lower method.
>>> line = 'Have a nice day'
>>> line.startswith('h')
False
>>> line.lower()
'have a nice day'
>>> line.lower().startswith('h')
True
 The format operator, % allows us to construct strings, replacing parts of the strings
with the data stored in variables.
 When applied to integers, % is the modulus operator. But when the first operand is
a string, % is the format operator.
 The first operand is the format string, which contains one or more format sequences
that specify how the second operand is formatted. The result is a string.
 For example, the format sequence “%d” means that the second operand should be
formatted as an integer (d stands for “decimal”):
>>> camels = 42
>>> '%d' % camels
'42'
 A format sequence can appear anywhere in the string, so you can
embed a value in a sentence:
>>> camels = 42
>>> 'I have spotted %d camels.' % camels
'I have spotted 42 camels.‘
 The following example uses “%d” to format an integer, “%g” to format
a floatingpoint number (don’t ask why), and “%s” to format a string:
>>> 'In %d years I have spotted %g %s.' % (3, 0.1, 'camels')
'In 3 years I have spotted 0.1 camels.'
 The number of elements in the tuple must match the number of
format sequences in the string. The types of the elements also must
match the format sequences:
>>> '%d %d %d' % (1, 2)
TypeError: not enough arguments for format string
>>> '%d' % 'dollars'
TypeError: %d format: a number is required, not str
 In the first example, there aren’t enough elements;
 in the second, the element is the wrong type.
 Write a Python function to create the HTML string with tags around the word(s).
 Sample function and result :
Input Tag:I
Input Word:Python
<i>Python</i>‘

Input Tag:b
Input Word: Python Tutorial
<b>Python Tutorial </b>
 def add_tags(tag, word):
 return "<%s>%s</%s>" % (tag, word, tag)
 tag=input("Enter the tag:")
 str=input("Enter the string:")
 html=add_tags(tag,str)
 print("HTML OUTPUT:",html)