Python Lists, Tuples, Dictionaries: brief important questions and answers

1. Explain in detail about lists, list operations and list slices.

A list is an ordered set of values, where each value is identified by an index. The values that make up a list are called its elements. Lists are similar to strings, which are ordered sets of characters, except that the elements of a list can have any type. There are several ways to create a new list.  The simplest is to enclose the elements in square brackets ([and]):

[10, 20, 30, 40]

["spam", "bungee", "swallow"]

The following list contains a string, a float, an integer, and (mirabile dictu) another list:

["hello", 2.0, 5, [10, 20]]

A list within another list is said to be nested. Lists that contain consecutive integers are common, so Python provides a simple way to create them:

>>> range (1,5) [1, 2, 3, 4].

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]

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 we omit the first index, the slice starts at the beginning. If we omit the second, the slice goes to the end.

So if we omit both, the slice is a copy of the whole list.

>>> t[:] ['a', 'b', 'c', 'd', 'e', 'f']

Since lists are mutable, it is often useful to make a copy before performing operations that fold, spindle or mutilate lists. 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,]

Like strings, lists can be indexed and sliced:

>>>     list = [2, 4, "usurp", 9.0, "n"]

>>>     list[2]

'usurp'

>>>     list[3:]

[9.0, 'n']

Much like the slice of a string is a substring, the slice of a list is a list. However, lists differ from strings in that we can assign new values to the items in a list:

>>>     list[1] = 17

>>>     list

[2, 17, 'usurp', 9.0, 'n']

We can assign new values to slices of the lists, which don't even have to be the same length:

>>>     list[1:4] = ["opportunistic", "elk"]

>>>     list

[2, 'opportunistic', 'elk', 'n']

It's even possible to append items onto the start of lists by assigning to an empty slice:

>>>     list[:0] = [3.14, 2.71]

>>>     list

[3.14, 2.71, 2, 'opportunistic', 'elk', 'n']

Similarly, you can append to the end of the list by specifying an empty slice after the end:

>>>     list[len(list):] = ['four', 'score']

list

[3.14, 2.71, 2, 'opportunistic', 'elk', 'n', 'four', 'score']

You can also completely change the contents of a list:

>>>     list[:] = ['new', 'list', 'contents']

>>>     list

['new', 'list', 'contents']

The right-hand side of a list assignment statement can be any iterable type:

>>>     list[:2] = ('element',('t',),[])

>>>     list

['element', ('t',), [], 'contents']

With slicing you can create copy of list since slice returns a new list:

>>>     original = [1, 'element', []]

>>>     list_copy = original[:]

>>>     list_copy

[1, 'element', []]

>>>     list_copy.append('new element')

>>>     list_copy

[1, 'element', [], 'new element']

>>>     original

[1, 'element', []]

Note, however, that this is a shallow copy and contains references to elements from the original list, so be careful with mutable types:

>>>     list_copy[2].append('something')

>>>     original

[1, 'element', ['something']]

Non-Continuous slices

It is also possible to get non-continuous parts of an array. If one wanted to get every n-th occurrence of a list, one would use the :: operator. The syntax is a:b:n where a and b are the start and end of the slice to be operated upon.

>>>     list = [i for i in range(10) ]

>>>     list

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>     list[::2] [0, 2, 4, 6, 8]

list[1:7:2] [1, 3, 5]

2. Explain in detail about list methods and list loops with examples.

Python provides methods that operate on lists. Some of the methods are

·                 Append()

·                 Extend()

·                 Sort()

·                 Pop()

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']

Remove the item in the list at the index i and return it. If i is not given, remove the the last item in the list and return it.

>>>list = [1, 2, 3, 4]

>>>a = list.pop(0)

>>>  list [2, 3, 4]

>>>  a

List methods are all void; they modify the list and return None.

LIST LOOPS

Here are two functions that both generate ten million random numbers, and return the sum of the numbers.

They both work.

import random

joe = random.Random()

def sum1():

""" Build a list of random numbers, then sum them """ # Generate one random ˓→number

 xs = []

for i in range(10000000):

num = joe.randrange(1000 )

xs.append(num)

# Save it in our list

tot = sum(xs)

return tot

def sum2():

""" Sum the random numbers as we generate them """

tot = 0

for i in range(10000000):

num = joe.randrange(1000)

tot += num

return tot

print(sum1())

print(sum2())

3. Explain in detail about mutability and tuples with a Python program.

MUTABILITY

Unlike strings, lists are mutable, which means we can change their elements. Using the bracket operator on the left side of an assignment, we can update one of the elements:

>>>  fruit = ["banana", "apple", "quince"]

>>>  fruit[0] = "pear"

>>>  fruit[-1] = "orange"

>>>  print fruit [’pear’, ’apple’, ’orange’]

With the slice operator we can update several elements at once:

>>>     list = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]

>>>     list[1:3] = [’x’, ’y’]

>>>     print list [’a’, ’x’, ’y’, ’d’, ’e’, ’f’] \

We can also remove elements from a list by assigning the empty list to them:

>>>     list = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]

>>>     list[1:3] = []

>>>     print list [’a’, ’d’, ’e’, ’f’]

And we can add elements to a list by squeezing them into an empty slice at the desired location:

>>>     list = [’a’, ’d’, ’f’]

>>>     list[1:1] = [’b’, ’c’]

>>>     print list [’a’, ’b’, ’c’, ’d’, ’f’]

>>>     list[4:4] = [’e’]

>>>     print list [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]

Tuple assignment

It is often useful to swap the values of two variables. With conventional assignments, you have to use a temporary variable. For example, to swap a and b:

>>>     temp = a

>>>     a = b

>>>     b = temp

This solution is cumbersome; tuple assignment is more elegant:

>>> a, b = b, a

The left side is a tuple of variables; the right side is a tuple of expressions. Each value is assigned to its respective variable. All the expressions on the right side are evaluated before any of the assignments. The number of variables on the left and the number of values on the right have to be the same:

>>> a, b = 1, 2, 3

ValueError: too many values to unpack More generally, the right side can be any kind of sequence (string, list or tuple). For example, to split an email address into a user name and a domain, you could write:

>>> addr = 'monty@python.org'

>>> uname, domain = addr.split('@')

The return value from split is a list with two elements; the first element is assigned to uname, the second to domain.

>>>     print uname monty

>>>     print domain python.org

4. What is tuple assignment? Explain it with an example.

It is often useful to swap the values of two variables. With conventional assignments, you have to use a temporary variable. For example, to swap a and b:

>>>     temp = a

>>>     a = b

>>>     b = temp

This solution is cumbersome; tuple assignment is more elegant:

>>> a, b = b, a

The left side is a tuple of variables; the right side is a tuple of expressions. Each value is assigned to its respective variable. All the expressions on the right side are evaluated before any of the assignments. The number of variables on the left and the number of values on the right have to be the same:

>>> a, b = 1, 2, 3

ValueError: too many values to unpack More generally, the right side can be any kind of sequence (string, list or tuple). For example, to split an email address into a user name and a domain, you could write:

>>>     addr = 'monty@python.org'

>>>     uname, domain = addr.split('@')

The return value from split is a list with two elements; the first element is assigned to uname, the second to domain.

>>>     print uname monty

>>>     print domain python.org

5. Is it possible to return tuple as values? Justify your answer with an example.

Yes, it is possible to return tuple as values. Example: Functions can return tuples as return values. For example, we could write a function that swaps two parameters:

def swap(x, y):

return y, x

Then we can assign the return value to a tuple with two variables:

a, b = swap(a, b)

In this case, there is no great advantage in making swap a function. In fact, there is a danger in trying to encapsulate swap, which is the following tempting mistake:

def swap(x, y): # incorrect version

x, y = y, x

If we call this function like this: swap(a, b) then a and x are aliases for the same value. Changing x inside swap makes x refer to a different value, but it has no effect on a in main. Similarly, changing y has no effect on b. This function runs without producing an error message, but it doesn’t do what we intended. This is an example of a semantic error.

The built-in function divmod takes two arguments and returns a tuple of two values, the quotient and remainder. You can store the result as a tuple:

>>>     t = divmod(7, 3)

>>>     print t (2, 1)

Or use tuple assignment to store the elements separately:

>>>     quot, rem = divmod(7, 3)

>>>     print quot 2

>>>     print rem 1

Here is an example of a function that returns a tuple: def min_max(t): return min(t), max(t) max and min are built-in functions that find the largest and smallest elements of a sequence. min_max computes both and returns a tuple of two values.

6. Explain in detail about dictionaries and its operations.

DICTIONARIES

A dictionary is like a list, but more general. In a list, the indices have to be integers; in a dictionary they can be (almost) any type. You can think of a dictionary as a mapping between a set of indices (which are called keys) and a set of values. Each key maps to a value. The association of a key and a value is called a key-value pair or sometimes an item. As an example, we’ll build a dictionary that maps from English to Spanish words, so the keys and the values are all strings.

The function dict creates a new dictionary with no items. Because dict is the name of a built-in function, you should avoid using it as a variable name.

>>> eng2sp = dict()

>>> print eng2sp {}

The squiggly-brackets, {}, represent an empty dictionary. To add items to the dictionary, you can use square brackets: >>> eng2sp['one'] = 'uno' This line creates an item that maps from the key 'one' to the value 'uno'. If we print the dictionary again, we see a key-value pair with a colon between the key and value:

>>> print eng2sp {'one': 'uno'}

This output format is also an input format. For example, you can create a new dictionary with three items:

>>>     eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}

But if you print eng2sp, you might be surprised:

>>>     print eng2sp {'one': 'uno', 'three': 'tres', 'two': 'dos'}

The order of the key-value pairs is not the same. In fact, if you type the same example on your computer, you might get a different result. In general, the order of items in a dictionary is unpredictable. But that’s not a problem because the elements of a dictionary are never indexed with integer indices. Instead, you use the keys to look up the corresponding values:

>>> print eng2sp['two'] 'dos'

The key 'two' always maps to the value 'dos' so the order of the items doesn’t matter. If the key isn’t in the dictionary, you get an exception:

>>> print eng2sp['four'] KeyError: 'four'

The len function works on dictionaries; it returns the number of key-value pairs:

>>>     len(eng2sp)

3

The in operator works on dictionaries; it tells you whether something appears as a key in the dictionary (appearing as a value is not good enough).

>>>     'one' in eng2sp True

>>>     'uno' in eng2sp False

To see whether something appears as a value in a dictionary, you can use the method values, which returns the values as a list, and then use the in operator:

>>>     vals = eng2sp.values()

>>>     'uno' in vals

True

The in operator uses different algorithms for lists and dictionaries. For lists, it uses a search algorithm, as in Section 8.6. As the list gets longer, the search time gets longer in direct proportion. For dictionaries, Python uses an algorithm called a hashtable that has a remarkable property: the in operator takes about the same amount of time no matter how many items there are in a dictionary

Dictionary operations

The del statement removes a key-value pair from a dictionary. For example, the following dictionary contains the names of various fruits and the number of each fruit in stock:

>>>     inventory = {’apples’: 430, ’bananas’: 312, ’oranges’: 525, ’pears’: 217}

>>>     print inventory {’oranges’: 525, ’apples’: 430, ’pears’: 217, ’bananas’: 312}

If someone buys all of the pears, we can remove the entry from the dictionary:

>>>     del inventory[’pears’]

>>>     print inventory {’oranges’: 525, ’apples’: 430, ’bananas’: 312}

Or if we’re expecting more pears soon, we might just change the value associated with pears:

>>>     inventory[’pears’] = 0

>>>     print inventory {’oranges’: 525, ’apples’: 430, ’pears’: 0, ’bananas’: 312}

The len function also works on dictionaries; it returns the number of key-value pairs:

>>>     len(inventory) 4

7. Explain in detail about dictionary methods.

DICTIONARY METHODS

A method is similar to a function—it takes arguments and returns a value— but the syntax is different. For example, the keys method takes a dictionary and returns a list of the keys that appear, but instead of the function syntax keys(eng2sp), we use the method syntax eng2sp.keys().

>>> eng2sp.keys() [’one’, ’three’, ’two’]

This form of dot notation specifies the name of the function, keys, and the name of the object to apply the function to, eng2sp. The parentheses indicate that this method has no parameters. A method call is called an invocation; in this case, we would say that we are invoking keys on the object eng2sp.

The values method is similar; it returns a list of the values in the dictionary:

>>> eng2sp.values() [’uno’, ’tres’, ’dos’]

The items method returns both, in the form of a list of tuples—one for each key-value pair:

>>> eng2sp.items() [(’one’,’uno’), (’three’, ’tres’), (’two’, ’dos’)]

The syntax provides useful type information. The square brackets indicate that this is a list. The parentheses indicate that the elements of the list are tuples. If a method takes an argument, it uses the same syntax as a function call. For example, the method has key takes a key and returns true (1) if the key appears in the dictionary:

>>> eng2sp.has_key(’one’)

True

>>> eng2sp.has_key(’deux’)

False

If you try to call a method without specifying an object, you get an error. In this case, the error message is not very helpful:

>>>     has_key(’one’) NameError: has_key 108

8. Explain in detail about list comprehension .Give an example.

List comprehensions

List comprehensions provide a concise way to create lists. It consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The expressions can be anything, i.e., all kinds of objects can be in lists. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. The list comprehension always returns a result list.

Syntax

The list comprehension starts with a '[' and ']', to help you remember that the result is going to be a list.

The basic syntax is

[ expression for item in list if conditional ]

This is equivalent to:

for item in list:

if conditional:

expression

List comprehension is a method to describe the process using which the list should be created. To do that, the list is broken into two pieces. The first is a picture of what each element will look like, and the second is what is done to get it.

For instance, let's say we have a list of words:

listOfWords = ["this","is","a","list","of","words"]

To take the first letter of each word and make a list out of it using list comprehension:

>>>     listOfWords = ["this","is","a","list","of","words"]

>>>     items = [ word[0] for word in listOfWords ]

>>>     print items

['t', 'i', 'a', 'l', 'o', 'w']

List comprehension supports more than one for statement. It will evaluate the items in all of the objects sequentially and will loop over the shorter objects if one object is longer than the rest.

>>>     item = [x+y for x in 'cat' for y in 'pot']

>>>     print item

['cp', 'co', 'ct', 'ap', 'ao', 'at', 'tp', 'to', 'tt']

List comprehension supports an if statement, to only include members into the list that fulfill a certain condition:

>>>     print [x+y for x in 'cat' for y in 'pot']

['cp', 'co', 'ct', 'ap', 'ao', 'at', 'tp', 'to', 'tt']

>>>print [x+y for x in 'cat' for y in 'pot' if x != 't' and y != 'o' ] ['cp', 'ct', 'ap', 'at']

print [x+y for x in 'cat' for y in 'pot' if x != 't' or y != 'o' ] ['cp', 'co', 'ct', 'ap', 'ao', 'at', 'tp', 'tt']

9. Write a Python program for a) selection sort b) insertion sort.

SELECTION SORT: PROGRAM:

def selectionsort( aList ):

for i in range( len( aList ) ): least = i

for k in range( i + 1 , len( aList ) ):

if aList[k] < aList[least]:

least = k

swap( aList, least, i )

def swap( A, x, y ):

tmp = A[x]

A[x] = A[y]

A[y] = tmp

aList = [54,26,93,17,77,31,44,55,20]

selectionsort(aList)

print(aList)

Insertion sort:

def insertionSort(alist):

for index in range(1,len(alist)):

currentvalue = alist[index]

position = index

while position>0 and alist[position-1]>currentvalue:

alist[position]=alist[position-1]

position = position-1

alist[position]=currentvalue

alist = [54,26,93,17,77,31,44,55,20]

insertionSort(alist)

print(alist)

10. Write a Python program for a) merge sort b) quick sort.

Merge sort:

def mergeSort(alist):

print("Splitting ",alist)

if len(alist)>1:

mid = len(alist)//2

lefthalf = alist[:mid]

righthalf = alist[mid:]

mergeSort(lefthalf)

mergeSort(righthalf)

i=0

j=0

k=0

while i < len(lefthalf) and j < len(righthalf):

if lefthalf[i] < righthalf[j]:

alist[k]=lefthalf[i]

i=i+1

else:

alist[k]=righthalf[j]

j=j+1

k=k+1

while i < len(lefthalf):

alist[k]=lefthalf[i]

i=i+1

k=k+1

while j < len(righthalf):

alist[k]=righthalf[j]

j=j+1

k=k+1

print("Merging ",alist)

alist = [54,26,93,17,77,31,44,55,20]

mergeSort(alist)

print(alist)

Quicksort:

from random import randrange

def partition(lst, start, end, pivot):

lst[pivot], lst[end] = lst[end], lst[pivot]

store_index = start

for i in xrange(start, end):

if lst[i] < lst[end]:

lst[i], lst[store_index] = lst[store_index], lst[i]

store_index += 1

lst[store_index], lst[end] = lst[end], lst[store_index]

return store_index

def quick_sort(lst, start, end):

if start >= end:

return lst

pivot = randrange(start, end + 1)

new_pivot = partition(lst, start, end, pivot)

quick_sort(lst, start, new_pivot - 1)

quick_sort(lst, new_pivot + 1, end)

def sort(lst):

quick_sort(lst, 0, len(lst) - 1)

return lst

print sort([-5, 3, -2, 3, 19, 5])

print sort([345,45,89,569,23,67,56,90,100])

def histogram( items ):

for n in items:

output = ''

times = n

while( times > 0 ):

output += '*'

times = times - 1

print(output)

histogram([2, 3, 6, 5])