Scribd
Upload
24 views

Tuple

Tuples are similar to lists but are immutable. They are defined using commas to separate elements and can contain heterogeneous data types. Tuples allow indexing, slicing, and length checking like lists but do not support item assignment. Functions can return multiple values using tuples. The random module can generate random numbers within a range for tuples. Tuples are commonly used to return multiple values from functions.

Uploaded by

ASHISH
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
24 views

Tuple

Tuples are similar to lists but are immutable. They are defined using commas to separate elements and can contain heterogeneous data types. Tuples allow indexing, slicing, and length checking like lists but do not support item assignment. Functions can return multiple values using tuples. The random module can generate random numbers within a range for tuples. Tuples are commonly used to return multiple values from functions.

Uploaded by

ASHISH
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 15

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

You might also like