Tuples:
-->Tuple items are ordered, immutable(unchangeable), and allow duplicate values.
-->Tuples are written with round brackets().
-->Tuples also allows indexing,slicing.
-->Tuples are similar to list and can perform addition,multiplication,Few same functions can be used for tuples also.
Examples:
t = (10,20,30)
print('output:1',t)
print('output:2',type(t))
print('output:3',end=' ')
for num in t:
print(num, end = ' ')
total = 0
print('output:4',end=' ')
for num in t:
total+=num
print(total)
t[0] = 100
Output:
output:1 (10, 20, 30)
output:2 <class 'tuple'>
output:3 10 20 30 output:4 60
'tuple' object does not support item assignment
-->For last output it shows error since tuple is immutable item assignment cannot be done.
Tuple packing and unpacking:
Tuple packing and unpacking are features that allow you to group values into a tuple and extract them back into individual variables.
Example:
#Tuple Packing
t = 10,20,30
print(t)
#Tuple Unpacking
no1, no2, no3 = t
print(no1)
print(no2)
print(no3)
Output:
(10, 20, 30)
10
20
30
Same functions can be used as list functions.
Example:
t1 = 10,20,30,40,50,60,10
print(t1.count(10))
print(t1.index(20))
print(sorted(t1))
print(sorted(t1,reverse=False))
Output:
2
1
[10, 10, 20, 30, 40, 50, 60]
[10, 10, 20, 30, 40, 50, 60]
1) Find
a)Second List
b)List wise total
c)Print Only second element from each list.
data = ([10,20,30],[40,50,60],[70,80,90])
data = ([10,20,30],[40,50,60],[70,80,90])
#Second List
print(data[1])
#List wise total
for inner in data:
total = 0
for num,index in enumerate(inner):
total+=index
print(total,end=' ')
#Print Only second element from each list.
print()
i=0
while i<len(data):
print(data[i][1],end=' ')
i+=1
Output:
[40, 50, 60]
60,150,240,
20 50 80
eval() function:
This function is used to evaluate whether the type of elements supplied through input() function is a list or a tuple.
t = eval(input("Enter tuple Elements: "))
print(type(t))
print(t)
Output:
Enter tuple Elements: 10,20,30
<class 'tuple'>
(10, 20, 30)
next() Function:
The next() function returns the next item in an iterator.
t = (no for no in range(1,11))
print(next(t))
print(next(t))
print(next(t))
print(next(t))
Output:
1
2
3
4
It iterates the next value in output.
Difference between 'is' and '==': (Interview question)
--> The '==' is known as the equality operator.
--> The 'is' is known as the identity operator.
-->== checks value.
-->is checks memory.
--> == operator helps us compare the equality of objects.
--> is operator helps us check whether different variables point towards a similar object in the memory.
Example:
For list:
l1 = [10,20,30]
l2 = l1
print(id(l1))
print(id(l2))
print(l1 == l2)
print(l1 is l2)
l2 = list(l1)
print(id(l2))
print(l1 == l2)
print(l1 is l2)
Output:
124653538036544
124653538036544
True
True
124653536481408
True
False
For Tuple:
l1 = (10,20,30)
l2 = l1
print(id(l1))
print(id(l2))
print(l1 == l2)
print(l1 is l2)
l2 = tuple(l1)
print(id(l2))
print(l1 == l2)
print(l1 is l2)
Output:
130906053714624
130906053714624
True
True
130906053714624
True
True
Tuple vs List:
-->Tuples are immutable objects and lists are mutable objects.
-->Tuples use less memory and are faster to access than to lists.
-->As tuples are immutable, size will be lesser than list.
Example:
import sys
l = [10,20,30,40]
t = (10,20,30,40)
print(sys.getsizeof(l))
print(sys.getsizeof(t))
Output:
88
72
Set:
-->Sets are used to store multiple items in a single variable.
-->A set is a collection which is unordered, immutable(unchangeable), and unindexed.
-->It ignore duplicates.
Set Methods:
1)union():(symbol-|)Return a set containing the union of sets.
2)intersection():(symbol-&)Returns a set, that is the intersection of two other sets.
3)difference():(symbol:'-')Returns a set containing the difference between two or more sets.
4)symmetric_difference():(symbol-^)Returns a set with the symmetric differences of two sets.
Example:1
s1 = {10,20,30,40}
s2 = {30,40,50,60}
print(s1.union(s2))
print(s1 | s2)
print(s1.intersection(s2))
print(s1 & s2)
print(s1.difference(s2))
print(s1 - s2)
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
Output:
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{40, 30}
{40, 30}
{10, 20}
{10, 20}
{10, 50, 20, 60}
{10, 50, 20, 60}
Example:2
s1 = {10,20}
s2 = {20,30}
s3 = {30,40}
print(s1.union(s2,s3))
result = s1 | s2 | s3
print(result)
Output:
{20, 40, 10, 30}
{20, 40, 10, 30}
Note: We can use symbols or method names.
discard():
--> It removes the element from the set only if the element is present in the set.
--> If the element is absent in the set, then no error or exception is raised and the original set is printed.
Difference between discard() and remove()
-->remove(): Removes the element from the set only if the element is present in the set, just as the discard() method does but If the element is not present in the set, then an error or exception is raised.
-->In discard() no error or exception is raised and the original set is printed.
Refer-https://www.geeksforgeeks.org/python-remove-discard-sets/
Example:
s = {"abcd", 1.2, True, 500,500}
s.remove(10)
print(s)
s.discard(10)
print(s)
Output:
KeyError: 10
{'abcd', 1.2, 500, True}
Tasks:
match1 = {"sanju", "virat", "ashwin", "rohit"}
match2 = {"dhoni", "virat", "bumrah", "siraj"}
Find the following:
a)Both match1, match2
b)Played in Match1 but not in match2
c)Played in Match2 but not in match 1
d)Played in Only one match
match1 = {"sanju", "virat", "ashwin", "rohit"}
match2 = {"dhoni", "virat", "bumrah", "siraj"}
#a
print(match1 & match2)
#b
print(match1 - match2)
#c
print(match2 - match1)
#d
print(match1 ^ match2)
Output:
{'virat'}
{'sanju', 'rohit', 'ashwin'}
{'dhoni', 'siraj', 'bumrah'}
{'sanju', 'bumrah', 'rohit', 'siraj', 'ashwin', 'dhoni'}
Top comments (0)