x = 3               #integer 
print(type(x)) 
y = 3.2233          #float
print(type(x)) 
z = 3 + 7.899j      #complex
print(type(z)) 
a = 3.222342522525664667 
print(a)  

Output:

<class ‘int’>
<class ‘int’>
<class ‘complex’>
3.2223425225256648

# Empty List
x = []
print("\n Empty List")
print(x)

# List with single data type
y = ["takeuforward", "striver", "tuf"]
print("\n List with Same data type ")
print(y)

# List with multiple data types
z = ["takeuforward", 8.90, 7, 9+899j, ["tuf", "striver"]]
print("\n List with multiple data types")
print(z) 

Output:

Empty List
[]

List with Same data type
[‘takeuforward’, ‘striver’, ‘tuf’]

List with multiple data types
[‘takeuforward’, 8.9, 7, (9+899j), [‘tuf’, ‘striver’]]

# list
x = ["takeuforward", "striver", "tuf", "python"]

print("\nAccessing the elements using the index ")
# prints the first element in x i.e "takeuforward"
print(x[0])

# prints the third element in x i.e "tuf"
print(x[2])

print("\nAccessing the elements using the Negative Indexing")
# prints the last element is x i.e "python"
print(x[-1])

# prints the third element from last i.e "striver"
print(x[-3]) 

Output:

Accessing the elements using the index
takeuforward
tuf

Accessing the elements using the Negative Indexing
python
striver

[tabyending]

Tuple : 

Tuples are like lists, the only difference between list and tuple is, that lists are mutable whereas the tuples are immutable. Mutable means the data can be changed, immutable means the data cannot be changed once it is created. So for the list, new data can be added, and existing data can be changed whereas for tuples data cannot be added or changed. 

Declaration of Tuple: 

A tuple can be created by placing the comma-separated values in parenthesis ().

Code:

# Empty tuple
x = ()
print("Empty Tuple")
print(x)

# tuple of similar data type
y = ("striver", "python")
print("\nTuple of Same data type ")
print(y)

# tuple of multiple data types
z = (4.5, "tuf", 4+5j)
print("\nTuple of different data types")
print(z)

print("\n Accessing through positive Indexing")
# prints first element in tuple
print(z[0])


print("\n Accessing through Negative Indexing")
# prints last element in tuple
print(z[-1])

Output:

Empty Tuple 
()

Tuple of Same data type
(‘striver’, ‘python’)

Tuple of different data types
(4.5, ‘tuf’, (4+5j))

Accessing through positive Indexing
4.5

 Accessing through Negative Indexing
(4+5j)

# string with single quotes
y = 'takeuforward'
print("\nString with Single quotes")
print(y)

# string with double quotes
z = "striver"
print("\nString with double quotes")
print(z)

# string with triple quotes
p = """This is Multiline 
string in python"""
print("\nMultiline string using triple quotes")
print(p)

# prints last character of z
print("\nz[-1] : ", z[-1])

# print first character of z
print("\nz[0] : ", z[0])

# raises a Error because strings are immutable
z[2] = 'c' 

Output:

String with Single quotes
takeuforward

String with double quotes
striver

Multiline string using triple quotes
This is Multiline
string in python

z[-1] :  r
z[0] :  s

TypeError: ‘str’ object does not support item assignment

# Empty set
x = {}
print("\n Empty Set")
print(x)

# Set with similar data type values
y = {1, 2, 3, 4}
print("\nSet with similar data type")
print(y)

# Set with multiple data types
z = {"striver", 1, (1, 3, 4)}
print("\nSet with multiple data types")
print(z)

#Here we assign the duplicates into set,but set takes only unique items.
#see the output,only unique elements are found in set.
print("\n")
p = {1, 1, 2, 2, "striver", "tuf", "tuf", 3, 3}
print(p)

Output:

Empty Set
{}

Set with similar data type
{1, 2, 3, 4}

Set with multiple data types
{1, ‘striver’, 1, 3, 4)}

{‘tuf’, 1, 2, 3, ‘striver’}

x = {1, 2, "python", "tuf"}

# Accessing the set elements using for loop
print("\nThe elements in the Set are : ")
for item in x:
    print(item)

# Finding whether key is present in set or not.
print('\n')
# checking is "python" present in x
print("python" in x)

print('\n')
# checking is "striver" present in x
print("striver" in x)

Output:

The elements in the Set are :
1
2
python
tuf

True

False

# Empty Dictonary
dict = {}
print("Empty Dictonary")
print(dict)

# Dictonary with similar data types of key
dict1 = {1: "striver",
         2: "tuf",
         3: [1, 2, 3]}
print("\nDictonary with the Integer keys")
print(dict1)


# Dictonary with Mixed data types of keys
print("\nDictonary with Mixed Data Types")
dict2 = {1: "tuf",
         "striver": "takeuforward",
         "kohli": "India",
         }
print(dict2)

# Dictonary with Case Sensitive keys
print("\nDictonary with Case Sensitive keys")
dict3 = {"IPL": ["RCB", "MI", "CSK"],
         "ipl": {"RR", "SRH", "LSG"}}
print(dict3)


# Dictonary with duplicate keys.
#last value i.e Raja Vikramaditya is taken as value to key striver.
print("\n Dictonary with Duplicate keys")
dict4 = {"striver": "tuf",
         "striver": "Raja Vikramaditya"}
print(dict4)

Output:

Empty Dictonary
{}

Dictonary with the Integer keys
{1: ‘striver’, 2: ‘tuf’, 3: [1, 2, 3]}

Dictonary with Mixed Data Types
{1: ‘tuf’, ‘striver’: ‘takeuforward’, ‘kohli’: ‘India’}

Dictonary with Case Sensitive keys
{‘IPL’: [‘RCB’, ‘MI’, ‘CSK’], ‘ipl’: {‘SRH’, ‘RR’, ‘LSG’}}

Dictonary with Duplicate keys
{‘striver’: ‘Raja Vikramaditya’}

dict1 = {1: "striver",
         2: "tuf",
         3: [1, 2, 3]}

# accessing a element using key
print("\nAccessing element using key")
# prints value corresponding to key 1
print(dict1[1])
# prints value corresponding to key 2
print(dict1[2])

Output:

Accessing element using key
striver
tuf