Day-27 Tuples, Set

Tuples:
Tuples maintain the order of elements as they are defined.
Once a tuple is created, its contents cannot be changed.
Like lists, tuples can contain duplicate values.
Tuples can store mixed types of data, including other tuples, lists, integers, strings, etc.
You can access tuple elements by their index, starting from 0.
Tuple represented by ().

t = (10,20,30)
print(t)
print(type(t))

for num in t:
    print(num)

total = 0
for num in t:
    total+=num
print(total)

t[0] = 100

(10, 20, 30)
<class 'tuple'>
10
20
30
60
TypeError: 'tuple' object does not support item assignment

Tuple packing:
Creating a tuple by grouping multiple elements together, e.g., my_tuple = (1, 2, 3).
Tuple unpacking:
Extracting the elements of a tuple into individual variables, e.g., a, b, c = my_tuple.

#Tuple Packing
t = 10,20,30
print(t)

#Tuple Unpacking
no1, no2, no3 = t
print(no1)
print(no2)
print(no3)

(10, 20, 30)
10
20
30

t = 10,20,30,40,50,60
print(t[:2])

(10, 20)

t1 = 10,20,30
t2 = 40,50,60
print(t1+t2)

print(t1*3)

print(10 in t1)
print(10 not in t1)

(10, 20, 30, 40, 50, 60)
(10, 20, 30, 10, 20, 30, 10, 20, 30)
True
False

t1 = 10,20,30,40,50,60,10

print(t1.count(10))
print(t1.index(20))
print(sorted(t1))
print(sorted(t1,reverse=True))

2
1
[10, 10, 20, 30, 40, 50, 60]
[60, 50, 40, 30, 20, 10, 10]

t = ((10,20,30), (40,50,60))
print(t)
print(t[0])
print(t[1])

print(t[0][0])
print(t[1][2])

t = ([10,20,30],[40,50,60])

print(t[0])
print(t[0][2])

((10, 20, 30), (40, 50, 60))
(10, 20, 30)
(40, 50, 60)
10
60
[10, 20, 30]
30

Write a program to 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

[40, 50, 60]
60,150,240,
20 50 80

eval():
eval() is a built-in Python function used to evaluate a string as a Python expression and return the result.

No tuple comprehension.

t = eval(input("Enter tuple Elements: "))
print(type(t))
print(t)

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

1
2
3
4

*Difference between 'is' and '==': *
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)

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)

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

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():(|)Return a set containing the union of sets.

2)intersection():(&)Returns a set, that is the intersection of two other sets.

3)difference():(-)Returns a set containing the difference between two or more sets.

4)symmetric_difference():(^)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)

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

{20, 40, 10, 30}
{20, 40, 10, 30}

discard():
The discard() method removes an element from the set if it exists. If the element is not present, it does nothing (no error is raised).
remove():
The remove() method removes an element from the set if it exists. If the element is not present, it raises a KeyError.

s = {"abcd", 1.2, True, 500,500}
s.remove(10)
print(s)

s.discard(10)
print(s)

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"}
print(match1 & match2)
print(match1 - match2)
print(match2 - match1)
print(match1 ^ match2)

{'virat'}
{'sanju', 'rohit', 'ashwin'}
{'dhoni', 'siraj', 'bumrah'}
{'sanju', 'bumrah', 'rohit', 'siraj', 'ashwin', 'dhoni'}