# List Manipulation

## Multiple Choice Questions

#### Question 1

List can contain values of these types:

1. integers
2. floats
3. lists
4. tuples
5. all of these ✓

#### Question 2

Which of the following will create an empty list?

1. L = [ ] ✓
2. L = list(0)
3. L = list( ) ✓
4. L = List(empty)

#### Question 3

Which of the following will return the last element of a list L with 5 elements?

1. L
2. L ✓
3. L[-1] ✓
4. L

#### Question 4

If L = [1, 2] then L * 2 will yield

1. [1, 2] * 2
2. [1, 2, 2]
3. [1, 1, 2, 2]
4. [1, 2, 1, 2] ✓

#### Question 5

If L1 = [1, 3, 5] and L2 = [2, 4, 6] then L1 + L2 will yield

1. [1, 2, 3, 4, 5, 6]
2. [1, 3, 5, 2, 4, 6] ✓
3. [3, 7, 11]
4. [1, 3, 5, [2, 4, 6]]

#### Question 6

Given a list L= [10, 20, 30, 40, 50, 60, 70], what would L[1 : 4] return?

1. [10, 20, 30, 40]
2. [20, 30, 40, 50]
3. [20, 30, 40] ✓
4. [30, 40, 50]

#### Question 7

Given a list L= [10, 20, 30, 40, 50, 60, 70], what would L[2 : -2] return?

1. [10, 20, 30, 40]
2. [20, 30, 40, 50]
3. [20, 30, 40]
4. [30, 40, 50] ✓

#### Question 8

Given a list L= [10, 20, 30, 40, 50, 60, 70], what would L[-4 : -1] return?

1. [20, 30, 40]
2. [30, 40, 50]
3. [40, 50, 60] ✓
4. [50, 60, 70]

#### Question 9

Given a list L= [10, 20, 30, 40, 50, 60, 70], what would L[-3 : 99] return?

1. [20, 30, 40]
2. [30, 40, 50]
3. [40, 50, 60]
4. [50, 60, 70] ✓

#### Question 10

To find the last element of list namely 'smiles' in Python, .......... will be used.

1. smiles
2. smiles[-1] ✓
3. smiles[lpos]
4. smiles[:-1]

#### Question 11

Out of the following, what is correct syntax to copy one list into another?

1. listA = listB[ ]
2. listA = listB[:] ✓
3. listA = listB[ ]( )
4. listA = list(listB) ✓

#### Question 12

What is printed by the Python code?
print(list(range(3)))

1. [0, 1, 2, 3]
2. [1, 2, 3]
3. [0, 1, 2] ✓
4. 0, 1, 2

#### Question 13

Which of the following commands will create a list?

1. listl = list( )
2. listl = [ ]
3. listl = list([1, 2, 3])
4. all of these ✓

#### Question 14

What is the output when we execute list("hello")?

1. ['h', 'e', 'l', 'l', 'o'] ✓
2. ['hello']
3. ['llo']
4. ['olleh']

#### Question 15

What gets printed?

```names = ['Hasan', 'Balwant', 'Sean', 'Dia']
print(names[-1][-1])```
1. H
2. n
3. Hasan
4. Dia
5. a ✓

#### Question 16

What is the output of the following

```l = [None] * 10
print(len(l))```
1. 10 ✓
2. 0
3. Syntax Error
4. None

#### Question 17

Consider the list aList - ["SIPO", [1, 3, 5, 7] ]. What would the following code print?

`print(aList, aList)`
1. S, 3
2. S, 1
3. I, 3 ✓
4. I, 1

#### Question 18

Which of the following is a standard Python library function and not an exclusively list function?

1. append( )
2. remove( )
3. pop( )
4. len( ) ✓

#### Question 19

Which of the following can add only one value to a list?

2. append( ) ✓
3. extend( )
4. none of these

#### Question 20

Which of the following can add a list of elements to a list?

2. append( )
3. extend( ) ✓
4. none of these

#### Question 21

Which of the following will always return a list?

1. max( )
2. min( )
3. sort( )
4. sorted( ) ✓

#### Question 22

Which of the following can delete an element from a list if the index of the element is given?

1. pop( )
2. remove( )
3. del ✓
4. all of these

#### Question 23

Which of the following can delete an element from a list, if its value is given?

1. pop( )
2. remove( ) ✓
3. del
4. all of these

#### Question 24

Which of the following searches for an element in a list and returns its index?

1. search( )
2. find( )
3. index( ) ✓
4. lsearch( )

#### Question 25

Which of the following can copy a list to another list?

1. list( ) ✓
2. new( )
3. copy( ) ✓
4. = operator

## Fill in the Blanks

#### Question 1

Lists are mutable data types and thus their values can be changed.

#### Question 2

To create an empty list, function list() can used.

#### Question 3

The + operator adds one list to the end another list.

#### Question 4

The * operator replicates a list.

#### Question 5

To check if an element is in list, in operator is used.

#### Question 6

To delete a list slice from a list, del statement is used

#### Question 7

A nested list contains another list as its member.

#### Question 8

The insert() function is used to insert element at a designated position in a list.

#### Question 9

The pop() function is used to delete element to remove an element from designated index in a list.

#### Question 10

The extend() function can append a list elements to a list.

#### Question 11

The sort() function sorts a list and makes changes in the list.

#### Question 12

The sorted() function sorts a list and returns another list.

## True/False Questions

#### Question 1

The list( ) and copy( ) are the similar functions.
False

#### Question 2

The pop( ) and remove( ) are similar functions.
False

#### Question 3

A = [ ] and A = list( ) will produce the same result.
True

#### Question 4

Lists once created cannot be changed.
False

#### Question 5

To sort a list, sort( ) and sorted( ), both can be used.
True

#### Question 6

The extend( ) adds a single element to a list.
False

#### Question 7

The append( ) can add an element in the middle of a list.
False

#### Question 8

The insert( ) can add an element in the middle of a list.
True

#### Question 9

The del statement can only delete list slices and not single elements from a list.
False

#### Question 10

The del statement can work similar to the pop( ) function.
True

## Type A : Short Answer Questions/Conceptual Questions

#### Question 1

Discuss the utility and significance of Lists in Python, briefly.

Python lists are containers that can store an ordered list of values of same or different data types together in a single variable. The fact that elements of a list need not be homogeneous makes them highly adaptable and powerful data structure in Python. Lists provide fast access to its elements using index numbers. Python lists are mutable which makes them memory efficient. They serve as the basic building blocks for programs that process large amounts of data.

#### Question 2

What do you understand by mutability? What does "in place" memory updation mean?

Mutability means that the value of an object can be updated by directly changing the contents of the memory location where the object is stored. There is no need to create another copy of the object in a new memory location with the updated values. This updation of the existing memory location of the object is called as in place memory updation.

#### Question 3

Start with the list [8, 9, 10]. Do the following using list functions:

1. Set the second entry (index 1) to 17
2. Add 4, 5 and 6 to the end of the list
3. Remove the first entry from the list
4. Sort the list
5. Double the list
6. Insert 25 at index 3

listA = [8, 9, 10]

1. listA = 17
2. listA.extend([4, 5, 6])
3. listA.pop(0)
4. listA.sort()
5. listA = listA * 2
6. listA.insert(3, 25)

#### Question 4

If a is [1, 2, 3]

1. what is the difference (if any) between a * 3 and [a, a, a]?
2. is a * 3 equivalent to a + a + a?
3. what is the meaning of a[1:1] = 9?
4. what's the difference between a[1:2] = 4 and a[1:1] = 4?

1. a * 3 ⇒ [1, 2, 3, 1, 2, 3, 1, 2, 3]
[a, a, a] ⇒ [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
So, a * 3 repeats the elements of the list whereas [a, a, a] creates nested list.
2. Yes, both a * 3 and a + a + a will result in [1, 2, 3, 1, 2, 3, 1, 2, 3]
3. a[1:1] = 9 will cause an error because when list is modified using slices, the value being assigned must be a sequence but 9 is an integer not a sequence.
4. Both a[1:2] = 4 and a[1:1] = 4 will cause error because when list is modified using slices, the value being assigned must be a sequence but 4 is an integer not a sequence. Assuming the question was a[1:2] =  and a[1:1] = , a[1:2] =  will change element at index 1 to 4 as a[1:2] gives a slice with a as its only element. Thus, a becomes [1, 4, 3]. Coming to a[1:1] = , a[1:1] returns an empty slice so 4 is inserted into the list at index 1. Thus, a becomes [1, 4, 2, 3].

#### Question 5

What's a[1 : 1] if a is a list of at least two elements? And what if the list is shorter?

a[x:y] returns a slice of the sequence from index x to y - 1. So, a[1 : 1] will return an empty list irrespective of whether the list has two elements or less as a slice from index 1 to index 0 is an invalid range.

#### Question 6

How are the statements lst = lst + 3 and lst +=  different, where lst is a list? Explain.

The statement lst = lst + 3 will give error as + operator in Python requires that both its operands should be of the same type but here one operand is list and other is integer. The statement lst +=  will add 3 at the end of the lst as += when used with lists requires the operand on the right side to be an iterable and it will add each element of the iterable to the end of the list.

#### Question 7

How are the statements lst += "xy" and lst = lst + "xy" different, where lst is a list? Explain.

The statement lst = lst + "xy" will give error as + operator in Python requires that both its operands should be of the same type but here one operand is list and other is string. The statement lst += "xy" will add 'x' and 'y' at the end of the lst as += when used with lists requires the operand on the right side to be an iterable and it will add each element of the iterable to the end of the list.

#### Question 8

What's the purpose of the del operator and pop method? Try deleting a slice.

The del statement is used to remove an individual element or elements identified by a slice. It can also be used to delete all elements of the list along with the list object. For example,

```lst = [1, 2, 3, 4, 5, 6, 7, 8]
del lst   # delete element at index 1
del lst[2:5] # delete elements from index 2 to 4
del lst # delete complete list ```

pop() method is used to remove a single element from the given position in the list and return it. If no index is specified, pop() removes and returns the last element in the list. For example,

```lst = [1, 2, 3, 4, 5, 6, 7, 8]

# removes element at
# index 1 i.e. 2 from
# the list and stores
# in variable a
a = pop(1)

# removes the last element
# i.e. 8 from the list and
# stores in variable b
b = pop()```

#### Question 9

What does each of the following expressions evaluate to? Suppose that L is the list
["These", ["are", "a", "few", "words"], "that", "we", "will", "use"].

1. L[0::2]
2. "a" in L
3. L[:1] + L
4. L[2::2]
5. L in L

1. ['are', 'few']
2. True
3. ['These', 'are', 'a', 'few', 'words']
4. ['that', 'will']
5. True

Explanation

1. L returns ["are", "a", "few", "words"]. L[0::2] returns a slice of ["are", "a", "few", "words"] starting at index 0 covering every alternate element till the end of the list. So, final output is ['are', 'few'].
2. L is "are". As "a" is present in "are" so output is True.
3. L[:1] return L i.e. ["These"]. L returns ["are", "a", "few", "words"]. + operator adds the two in a single list to give the final output as ['These', 'are', 'a', 'few', 'words'].
4. L[2::2] returns a slice of L starting at index 2 covering every alternate element till the end of the list. So, final output is ['that', 'will'].
5. L is ["are", "a", "few", "words"]. L is "a". As "a" is present in L so output is True.

#### Question 10

What are list slices? What for can you use them?

List slice is an extracted part of the list containing the requested elements. The list slice is a list in itself. All list operations can be performed on a list slice. List slices are used to copy the required elements to a new list and to modify the required parts of the list. For example,

```lst = [1, 2, 3, 4, 5]
lst2 = lst[1:4] #lst2 is [2, 3, 4]

#Using Slices for list modification
lst[0:2] = [10, 20] #lst becomes [10, 20, 3, 4, 5]```

#### Question 11

Does the slice operator always produce a new list?

Slice operator copies only the requested elements of the original list into a new list.

#### Question 12

Compare lists with strings. How are they similar and how are they different?

The similarity between Lists and Strings in Python is that both are sequences. The differences between them are that firstly, Lists are mutable but Strings are immutable. Secondly, elements of a list can be of different types whereas a String only contains characters that are all of String type.

#### Question 13

What do you understand by true copy of a list? How is it different from shallow copy?

True copy of a list means that the elements of the original list are copied to new memory locations and the new list contains references to these new memory locations for each element of the list. Hence, in case of true copy changes made to the original list will not reflect in the copied list and vice versa.

Incase of shallow copy of a list, the elements of the original list are not copied to new memory locations. Both the new list and the original list refer to the same memory locations for the elements of the list. Hence, changes made to one of the list reflect in the other list as well.

#### Question 14

An index out of bounds given with a list name causes error, but not with list slices. Why?

When we use an index, we are accessing a constituent element of the list. If the index is out of bounds there is no element to return from the given index hence Python throws list index out of range error whereas list slicing always returns a subsequence and empty subsequence is a valid sequence. Thus, when a list is sliced outside the bounds, it still can return empty subsequence and hence Python gives no errors and returns empty subsequence.

#### Question 15

What is the difference between appending a list and extending a list?

Appending a listExtending a list
For appending to a list, append() function is used.For extending a list, extend() function is used.
The append() function can add a single element to the end of a list.The extend() function can add multiple elements from a list supplied to it as argument.
After append(), the length of the list will increase by 1 element only.After extend() the length of the list will increase by the length of the list given as argument to extend()

#### Question 16

Do functions max( ), min( ), sum( ) work with all types of lists.

No, for max() and min() to work on a list, the list must contain all elements of same type (non-complex type) and for sum() to work, the list must contain the elements which can be added such as numbers.

#### Question 17

What is the difference between sort( ) and sorted( )?

sort( )sorted( )
It modifies the list it is called on. That is, the sorted list is stored in the same list; a new list is not created.It creates a new list containing a sorted version of the list passed to it as argument. It does not modify the list passed as a parameter.
It works on a list and modifies it.It can take any iterable sequence type, such as a list or a tuple etc, and it always returns a sorted list irrespective of the type of sequence passed to it.
It does not return anything (no return value). It modifies the list in place.It returns a newly created sorted list. It does not change the passed sequence.

## Type B: Application Based Questions

#### Question 1

What is the difference between following two expressions, if lst is given as [1, 3, 5]

(i) lst * 3 and lst *= 3
(ii) lst + 3 and lst += 

(i)

lst * 3 will give [1, 3, 5, 1, 3, 5, 1, 3, 5] but the original lst will remains unchanged, it will be [1, 3, 5] only.
lst *= 3 will also give [1, 3, 5, 1, 3, 5, 1, 3, 5] only but it will assign this result back to lst so lst will be changed to [1, 3, 5, 1, 3, 5, 1, 3, 5].

(ii)

lst + 3 will cause an error as both operands of + operator should be of same type but here one operand is list and the other integer.
lst +=  will add 3 to the end of lst so lst becomes [1, 3, 5, 3].

#### Question 2

Given two lists:

L1 = ["this", 'is', 'a', 'List'], L2 = ["this", ["is", "another"], "List"]

Which of the following expressions will cause an error and why?

1. L1 == L2
2. L1.upper( )
3. L1.upper( )
4. L2.upper( )
5. L2.upper( )
6. L2.upper( )

• L1.upper( ) will cause an error as upper() method can be called with Strings not Lists.
• L2.upper( ) will cause an error as upper() method can be called with Strings not Lists.
• L2.upper( ) will cause an error as L2 is a list — [ "is", "another"] and upper() method cannot be called on Lists.

#### Question 3

From the previous question, give output of expressions that do not result in error.

• L1 == L2 gives output as false because L1 is not equal to L2.
• L1.upper( ) gives output as 'LIST' because L1 is 'List' and upper() function converts it to uppercase.
• L2.upper( ) gives output as 'ANOTHER' because L2 ["is", "another"] and L2 is "another". upper() function converts it to uppercase.

#### Question 4

Given a list L1 = [3, 4.5, 12, 25.7, [2, 1, 0, 5], 88]

1. Which list slice will return [12, 25.7, [2, 1, 0, 5]]?
2. Which expression will return [2, 1, 0, 5]?
3. Which list slice will return [[2, 1, 0, 5]]?
4. Which list slice will return [4.5, 25.7, 88]?

1. L1[2:5]
2. L1
3. L1[4:5]
4. L1[1::2]

#### Question 5

Given a list L1 = [3, 4.5, 12, 25.7, [2, 1, 0, 5], 88], which function can change the list to:

1. [3, 4.5, 12, 25.7, 88]
2. [3, 4.5, 12, 25.7]
3. [ [2, 1, 0, 5], 88]

1. L1.pop(4)
2. del L1[4:6]
3. del L1[:4]

#### Question 6

What will the following code result in?

```L1 = [1, 3, 5, 7, 9]
print (L1 == L1.reverse( ) )
print (L1)```

##### Output
``````False
[9, 7, 5, 3, 1]
``````
##### Explanation

L1 is not equal to its reverse so L1 == L1.reverse( ) gives False but L1.reverse( ) reverses L1 in place so after that statement executes, L1 becomes [9, 7, 5, 3, 1].

#### Question 7

Predict the output:

```my_list= [ 'p', 'r', 'o', 'b', 'l' , 'e', 'm']
my_list[2:3] = []
print(my_list)
my_list[2:5] = []
print(my_list)```

##### Output
``````['p', 'r', 'b', 'l', 'e', 'm']
['p', 'r', 'm']
``````
##### Explanation

my_list[2:3] = [] removes element at index 2 of my_list so it becomes ['p', 'r', 'b', 'l', 'e', 'm']. my_list[2:5] removes elements at indexes 2, 3, and 4 so now my_list becomes ['p', 'r', 'm'].

#### Question 8

Predict the output:

```List1 = [13, 18, 11, 16, 13, 18, 13]
print(List1.index(18))
print(List1.count(18))
List1.append(List1.count(13))
print(List1)```

##### Output
``````1
2
[13, 18, 11, 16, 13, 18, 13, 3]
``````
##### Explanation

List1.index(18) gives the first index of element 18 in List1 which in this case is 1. List1.count(18) returns how many times 18 appears in List1 which in this case is 2. List1.count(13) returns 3 as 13 appears 3 times in List1. List1.append(List1.count(13)) add this 3 to the end of List1 so it becomes [13, 18, 11, 16, 13, 18, 13, 3].

#### Question 9

Predict the output:

```Odd = [1,3,5]
print( (Odd +[2, 4, 6]) )
print( (Odd +[12, 14, 16]) - (Odd +[2, 4, 6]) )```

##### Output
``````4
10
``````
##### Explanation

Odd + [2, 4, 6] will return [1, 3, 5, 2, 4, 6]. The element at index 4 of this list is 4 so the first output is 4. (Odd +[12, 14, 16]) is 14 and (Odd +[2, 4, 6]) is 4. 14 - 4 = 10 which is the second output.

#### Question 10

Predict the output:

```a, b, c = [1,2], [1, 2], [1, 2]
print(a == b)
print (a is b)```

##### Output
``````True
False
``````
##### Explanation

As corresponding elements of list a and b are equal hence a == b returns True. a is b returns False as a and b are two different list objects referencing two different memory locations.

#### Question 11

Predict the output of following two parts. Are the outputs same? Are the outputs different? Why?

(a)

```L1, L2 = [2, 4] , [2, 4]
L3 = L2
L2 = 5
print(L3)               ```

(b)

```L1, L2 = [2, 4] , [2, 4]
L3 = list(L2)
L2 = 5
print(L3)```

Output of part (a) is:
[2, 5]

Output of part (b) is:
[2, 4]

As we can see, outputs of the two parts are different. The reason is that in part (a), the statement L3 = L2 creates a shallow copy of L2 in L3 i.e. both the variables L2 and L3 point to the same list. Hence, when element at index 1 of L2 is changed to 5, that change is visible in L3 also. On the other hand in part (b), the statement L3 = list(L2) creates a true copy (also called deep copy) of L2 so L3 points to a different list in memory which has the same elements as L2. Now when element at index 1 of L2 is changed to 5, that change is not visible in L3.

#### Question 12

Find the errors:

1. L1 = [1, 11, 21, 31]
2. L2 = L1 + 2
3. L3 = L1 * 2
4. Idx = L1.index(45)

• Line 2 — L2 = L1 + 2 will result in error as one element of + is a list and other is an integer. In Python, operands of + operator should be of same type.
• Line 4 — Idx = L1.index(45) will cause an error as 45 is not present in the list L1.

#### Question 13a

Find the errors:

```L1 = [1, 11, 21, 31]
An = L1.remove(41)```

L1.remove(41) will cause an error as 41 is not present in L1.

#### Question 13b

Find the errors:

```L1 = [1, 11, 21, 31]
An = L1.remove(31)
print(An + 2)```

An + 2 will cause an error because remove() function does not return the removed element so An will be None. Addition operator (+) does not allow any of its operands to be None hence, it will raise a TypeError.

#### Question 14a

Find the errors:

```L1 = [3, 4, 5]
L2 = L1 * 3
print(L1 * 3.0)
print(L2)```

The line print(L1 * 3.0) causes an error as Python does not allow multiplying a list with a non-int number and 3.0 is of float type.

#### Question 14b

Find the errors:

```L1 = [3, 3, 8, 1, 3, 0, '1', '0', '2', 'e', 'w', 'e', 'r']
print(L1[: :-1])
print(L1[-1:-2:-3])
print(L1[-1:-2:-3:-4])```

The line print(L1[-1:-2:-3:-4]) causes an error as its syntax is invalid. The correct syntax for slicing a list is L1[start:stop:step].

#### Question 15

What will be the output of following code?

```x = ['3', '2', '5']
y = ''
while x:
y = y + x[-1]
x = x[:len(x) - 1]
print(y)
print(x)
print(type(x), type(y))```

##### Output
``````523
[]
<class 'list'> <class 'str'>
``````
##### Explanation

The loop while x will continue executing as long as the length of list x is greater than 0. y is initially an empty string. Inside the loop, we are adding the last element of x to y and after that we are removing the last element of x from x. So, at the end of the loop y becomes 523 and x becomes empty. Type of x and y are list and str respectively.

#### Question 16

Complete the code to create a list of every integer between 0 and 100, inclusive, named nums1 using Python, sorted in increasing order.

nums1 = list(range(101))

#### Question 17

Let nums2 and nums3 be two non-empty lists. Write a Python command that will append the last element of nums3 to the end of nums2.

nums2.append(nums3[-1])

#### Question 18

Consider the following code and predict the result of the following statements.

```bieber = ['om', 'nom', 'nom']
counts = [1, 2, 3]
nums = counts
nums.append(4)```
1. counts is nums
2. counts is add([1, 2], [3, 4])

1. Output is True as both nums and counts refer to the same list.
2. This will cause an error as add function is not defined in the above code.

#### Question 19

What is the output of the following code?

```numbers = list(range(0, 51, 4))
results = []
for number in numbers:
if not number % 3:
results.append(number)
print(results)```

##### Output
``````[0, 12, 24, 36, 48]
``````
##### Explanation

list(range(0, 51, 4)) will create a list from 0 to 48 with a step of 4 so numbers will be [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48]. For loop will traverse the list one number at a time. if not number % 3 means if number % 3 is equal to 0 i.e. number is divisible by 3. The numbers divisible by 3 are added to the results list and after the loop results list is printed.

#### Question 20

Following code prints the given list in ascending order. Modify the code so that the elements are printed in the reverse order of the result produced by the given code.

```numbers = list(range(0, 51, 4))
i = 0
while i < len(numbers):
print(numbers[i] , end = " ")
i += 3
# gives output as : 0 12 24 36 48```

```numbers = list(range(0, 51, 4))
i = len(numbers) - 1
while i >= 0:
print(numbers[i] , end = " ")
i -= 3```
##### Output
``````48 36 24 12 0
``````

## Type C: Programming Practice/Knowledge based Questions

#### Question 1

Write a program to increment the elements of a list with a number.

##### Solution
```lst = eval(input("Enter a list: "))
print("Existing list is:", lst)

n = int(input("Enter a number: "))

for i in range(len(lst)):
lst[i] += n

print("List after increment:", lst)```
##### Output
``````Enter a list: [1, 2, 3, 4, 5]
Existing list is: [1, 2, 3, 4, 5]
Enter a number: 10
List after increment: [11, 12, 13, 14, 15]
``````

#### Question 2

Write a program that reverses a list of integers (in place).

##### Solution
```l = eval(input("Enter a list: "))
print("Original list:", l)
l.reverse()
print("Reversed list:", l)```
##### Output
``````Enter a list: [1, 2, 3, 4, 5]
Original list: [1, 2, 3, 4, 5]
Reversed list: [5, 4, 3, 2, 1]
``````

#### Question 3

Write a program that inputs two lists and creates a third, that contains all elements of the first followed by all elements of the second.

##### Solution
```l1 = eval(input("Enter first list: "))
l2 = eval(input("Enter second list: "))
l3 = l1 + l2
print("Joined List:", l3)```
##### Output
``````Enter first list: [1, 2, 3, 4, 5]
Enter second list: [11, 12, 13, 14, 15]
Joined List: [1, 2, 3, 4, 5, 11, 12, 13, 14, 15]
``````

#### Question 4

Ask the user to enter a list containing numbers between 1 and 12. Then replace all of the entries in the list that are greater than 10 with 10.

##### Solution
```l = eval(input("Enter list having numbers between 1 & 12: "))

for i in range(len(l)):
if l[i] > 10:
l[i] = 10

print("List after removing numbers greater than 10:")
print(l)```
##### Output
``````Enter list having numbers between 1 & 12: [1, 3, 15, 8, 20]
List after removing numbers greater than 10:
[1, 3, 10, 8, 10]
``````

#### Question 5

Ask the user to enter a list of strings. Create a new list that consists of those strings with their first characters removed.

##### Solution
```l1 = eval(input("Enter a list of strings: "))
l2 = []

for i in range(len(l1)):
l2.append(l1[i][1:])

print("List after removing first characters:")
print(l2)```
##### Output
``````Enter a list of strings: ["red", "green", "blue", "pink", "cyan"]
List after removing first characters:
['ed', 'reen', 'lue', 'ink', 'yan']
``````

#### Question 6

Write a program to check if a number is present in the list or not. If the number is present, print the position of the number. Print an appropriate message if the number is not present in the list.

##### Solution
```l = eval(input("Enter list: "))
n = int(input("Enter number to search: "))

if n in l:
print(n, "found at index", l.index(n))
else :
##### Output
``````Enter list: [1, 3, 15, 8, 20]
Enter number to search: 15
15 found at index 2

=====================================

Enter list: [1, 3, 15, 8, 20]
Enter number to search: 25
``````

#### Question 7a

Create the following lists using a for loop:

A list consisting of the integers 0 through 49.

##### Solution
```l = []

for i in range(50):
l.append(i)

print("List with integers from 0 to 49:")
print(l)```
##### Output
``````List with integers from 0 to 49:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
``````

#### Question 7b

Create the following lists using a for loop:

A list containing the squares of the integers 1 through 50.

##### Solution
```l = []

for i in range(1, 51):
l.append(i * i)

print("List with square of integers from 1 to 50:")
print(l)```
##### Output
``````List with square of integers from 1 to 50:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500]
``````

#### Question 7c

Create the following lists using a for loop:

The list ['a','bb','ccc','dddd', . . . ] that ends with 26 copies of the letter z.

##### Solution
```l = []

for i in range(1, 27):
l.append(chr(i + 96) * i)

print("Created List:")
print(l)```
##### Output
``````Created List:
['a', 'bb', 'ccc', 'dddd', 'eeeee', 'ffffff', 'ggggggg', 'hhhhhhhh', 'iiiiiiiii', 'jjjjjjjjjj', 'kkkkkkkkkkk', 'llllllllllll', 'mmmmmmmmmmmmm', 'nnnnnnnnnnnnnn', 'ooooooooooooooo', 'pppppppppppppppp', 'qqqqqqqqqqqqqqqqq', 'rrrrrrrrrrrrrrrrrr', 'sssssssssssssssssss', 'tttttttttttttttttttt', 'uuuuuuuuuuuuuuuuuuuuu',
'vvvvvvvvvvvvvvvvvvvvvv', 'wwwwwwwwwwwwwwwwwwwwwww', 'xxxxxxxxxxxxxxxxxxxxxxxx', 'yyyyyyyyyyyyyyyyyyyyyyyyy', 'zzzzzzzzzzzzzzzzzzzzzzzzzz']
``````

#### Question 8

Write a program that takes any two lists L and M of the same size and adds their elements together to form a new list N whose elements are sums of the corresponding elements in L and M. For instance, if L = [3, 1, 4] and M = [1, 5, 9], then N should equal [4,6,13].

##### Solution
```print("Enter two lists of same size")
L = eval(input("Enter first list(L): "))
M = eval(input("Enter second list(M): "))
N = []

for i in range(len(L)):
N.append(L[i] + M[i])

print("List N:")
print(N)```
##### Output
``````Enter two lists of same size
Enter first list(L): [3, 1, 4]
Enter second list(M): [1, 5, 9]
List N:
[4, 6, 13]
``````

#### Question 9

Write a program rotates the elements of a list so that the element at the first index moves to the second index, the element in the second index moves to the third index, etc., and the element in the last index moves to the first index.

##### Solution
```l = eval(input("Enter the list: "))
print("Original List")
print(l)

l = l[-1:] + l[:-1]

print("Rotated List")
print(l)```
##### Output
``````Enter the list: [8, 10, 13, 25, 7, 11]
Original List
[8, 10, 13, 25, 7, 11]
Rotated List
[11, 8, 10, 13, 25, 7]
``````

#### Question 10

Write a program that reads the n to display nth term of Fibonacci series.

The Fibonacci sequence works as follows:

• element 0 has the value 0
• element 1 has the value 1
• every element after that has the value of the sum of the two preceding elements

The beginning of the sequence looks like:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

The program prompts for element and prints out the value of that element of the Fibonacci sequence.

Thus:

• input 7, produces 13
• input 9, produces 34

Hints:
A Don't try to just type out the entire list. It gets big very fast. Element 25 is 75205. Element 100 is 354224848179261915075. So keep upper limit of n to 20.

##### Solution
```n = int(input("Enter n: "))

if (n > 20):
print("n should be less than or equal to 20")
else :
a = 0
b = 1
c = a + b
for i in range(3, n + 1):
a = b
b = c
c = a + b

print(n, "term of Fibonacci series =", c)```
##### Output
``````Enter n: 7
7 term of Fibonacci series = 13

=====================================

Enter n: 9
9 term of Fibonacci series = 34

=====================================

Enter n: 25
n should be less than or equal to 20
``````

#### Question 11a

Write programs as per following specifications:

'''Print the length of the longest
string in the list of strings str_list.
Precondition : the list will contain
at least one element.'''

##### Solution
```l = eval(input("Enter list of strings: "))
largeIdx = 0
largeLen = 0

for i in range(len(l)):
length = len(l[i])
if length > largeLen:
largeLen = length
largeIdx = i

print("Longest String:", l[largeIdx])```
##### Output
``````Enter list of strings: ["apple", "orange", "pear", "strawberry", "kiwi"]
Longest String: strawberry
``````

#### Question 11b

Write programs as per following specifications:

'''L is a list of numbers. Print a new list where each element is the corresponding element of list L summed with number num.'''

##### Solution
```l1 = eval(input("Enter list of numbers: "))
num = int(input("Enter the number to sum with (num): "))

l2 = []

for i in l1:
l2.append(i + num)

print("New list:")
print(l2)```
##### Output
``````Enter list of numbers: [10, 20, 30, 40, 50]
Enter the number to sum with (num): 15
New list:
[25, 35, 45, 55, 65]
``````

#### Question 12

Write a program to read two lists num and denum which contain the numerators and denominators of same fractions at the respective indexes. Then display the smallest fraction along with its index.

##### Solution
```num = eval(input("Enter numerators list: "))
denum = eval(input("Enter denominators list: "))

small = 0.0
smallIdx = 0

for i in range(len(num)):
t = num[i] / denum[i]
if t < small:
small = t
smallIdx = i

print("Smallest Fraction =", num[smallIdx], "/", denum[smallIdx])
print("Index of Smallest Fraction =", smallIdx)```
##### Output
``````Enter numerators list: [1, 3, 1, 7, 3]
Enter denominators list: [2, 4, 4, 13, 8]
Smallest Fraction = 1 / 2
Index of Smallest Fraction = 0
``````

#### Question 13

Write a program to display the maximum and minimum values from the specified range of indexes of list.

##### Solution
```l = eval(input("Enter the list: "))
start = int(input("Enter start index: "))
stop = int(input("Enter stop index: "))

slice = l[start : stop + 1]
mx = max(slice)
mi = min(slice)

print("Maximum =", mx)
print("Minimum =", mi)```
##### Output
``````Enter the list: [89, 42, 12, 56, 35, 2, 8, 7, 13, 69]
Enter start index: 3
Enter stop index: 8
Maximum = 56
Minimum = 2
``````

#### Question 14

Write a program to move all duplicate values in a list to the end of the list.

##### Solution
```l = eval(input("Enter the list: "))
dedup = []
dup = []
for i in l:
if i in dedup:
dup.append(i)
else:
dedup.append(i)

l = dedup + dup

print("Modified List:")
print(l)```
##### Output
``````Enter the list: [20, 15, 18, 15, 7, 18, 12, 13, 7]
Modified List:
[20, 15, 18, 7, 12, 13, 15, 18, 7]
``````

#### Question 15

Write a program to compare two equal sized lists and print the first index where they differ.

##### Solution
```print("Enter two equal sized lists")
l1 = eval(input("Enter first list: "))
l2 = eval(input("Enter second list: "))

for i in range(len(l1)):
if l1[i] != l2[i]:
print("Lists differ at index", i)
break;
else:
print("Lists are equal")```
##### Output
``````Enter two equal sized lists
Enter first list: [80, 60, 50, 40, 30]
Enter second list: [80, 60, 55, 42, 30]
Lists differ at index 2

=====================================

Enter two equal sized lists
Enter first list: [80, 60, 50, 40, 30]
Enter second list: [80, 60, 50, 40, 30]
Lists are equal
``````