Tuples
Tuple
• Similar to a list except it is immutable.
• Syntactically, it is comma-seperated list of values.
– tuple = 'a', 'b', 'c', 'd', 'e‘
• To create a tuple with a single element, we have to include the comma:
– t1 = ('a',)
– type(t1)
<type 'tuple'>
• Without the comma, Python treats ('a') as a string in parentheses:
– t2 = ('a')
– type(t2) ??
• The operations on tuples are the same as the operations on lists
• The index operator selects an element from a tuple.
– tuple = ('a', 'b', 'c', 'd', 'e')
– tuple[0]
– 'a‘
• The slice operator selects a range of elements.
– tuple[1:3]
– ('b', 'c‘)
• But if we try to modify one of the elements of the tuple, we get an error.
– tuple[0] = 'A'
– TypeError: object doesn't support item assignment
Example
• we can't modify the elements of a tuple, we can replace it with a
different tuple:
– tuple = ('A',) + tuple[1:]
– tuple
– ('A', 'b', 'c', 'd', 'e')
Tuple Assignment
• Tuple assignment allows the assignment of values to a tuple of
variables on the left side of the assignment from the tuple of values
on the right side of the assignment.
• E.g.
Anil=('1','Anil','kumar')
(id,f_name,lst_name)=Anil
>>>print(id)
1
Tuple Assignmnt
• To swap the values, using conventional assignment statements, we have to
use the assignment statement with a temporary variable.
– temp = a
– a=b
– b = temp
• Python provides a form of tuple assignment that solves this problem neatly:
– a, b = b, a
• The number of variables on the left and the number of values on the right
have to be the same.
Tuples as Return Values
• Functions can return tuples as return values.
• For example:
– 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)
def swap(x, y): # incorrect version
x, y = y, x
• If we call this function like this:
swap(a, b)
• 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.
Random Numbers
• The random module contains a function called random that returns a
floating point number between 0.0 and 1.0.
• Each time you call random, you get the next number in a long series.
import random
#random number between some range
• import random
print(random.randint(2,9))
continued
import random
for x in range(5):
print(random.randrange(2,60,2))
#for float
import random
for x in range(5):
print(random.random())
#choice based
import random
t1 = 1, 2, 3, 4, 5, 6,44444444,66,7
print(random.choice(t1))
List of Random Numbers(float)
randomList(8)
0.15156642489
0.498048560109
0.810894847068
0.360371157682
0.275119183077
0.328578797631
0.759199803101
0.800367163582
Counting
• Divide the problem into sub problems and look for sub problems that fit a computational
pattern
• Traverse a list of numbers and count the number of times a value falls in a given range.
• Eg:
def inBucket(t, low, high):
count = 0
for num in t:
if low < num < high:
count = count + 1
return count
This development plan is known as pattern matching.
Many Buckets
• With two buckets, range will be:
– low = inBucket(a, 0.0, 0.5)
– high = inBucket(a, 0.5, 1)
• But with four buckets it is:
– bucket1 = inBucket(a, 0.0, 0.25)
– bucket2 = inBucket(a, 0.25, 0.5)
– bucket3 = inBucket(a, 0.5, 0.75)
– bucket4 = inBucket(a, 0.75, 1.0)
Basic Tuple Operations
• Concatenation: works in the same way as it does in lists. ‘+’ operator
is used for concatenation.
• Repetition: It is performed by ‘*’ operator. E.g: (‘Hello’,)*4
• In Operator: It tells user that the given element exists in the tuple or
not. It gives a Boolean output. E.g.
>>>Tuple=(’10’,’20’,’30’)
>>>20 in tuple
True
Built-in Tuple Operations
• Len(tuple): returns the length of a tuple
• Min(tuple): returns smallest value among all the elements
• Max(tuple): returns largest value among all the elements
• Cmp(tuple1, tuple2): compares items of two tuples
• Tuple(seq): converts a list into a tuple
• Zip(tuple1,tuple2): it zips elements from two tuples into a list of tuples.
e.g.
>>>tuple1=(‘a’,’b’,’c’)
>>>tuple2=(1,2,3)
>>>Zip(tuple1,tuple2)
[(‘a’,1),(‘b’,2),(‘c’,3)]
