id()
===
==> inbuilt method, which we can use to find the address location of the data (stack memory).
Syntax:
	id(name of the data) or
	id(value)

a = 100 #140733395174936
b = 200 # 140733395178136
c = 300 # 2954331794960

print(id(a))
print(id(b))
print(id(c))

# memory of the data is never be permanent,
# the memory of the data can be get assigned when the program will start and that assigned memory will be get released
# when the program is closed.



MUTABILITY Vs IMMUTABILITY
==========================

IMMUTABILITY
=============
ALL THE PRIMITIVE DATATYPES ARE ==> IMMUTABLE TYPE OF DATATYPES
IMMUTABILITY ==> WHEN WE HAVE DEFINED A DATA IN THE PROGRAM, WHICH IT CANNOT BE GET MODIFIED AGAIN AND AGIN.
IF THE MODIFICATION IS PERFORMED ON THE DATA, THE MEMORY WHICH WAS ASSIGNED EARLIER THAT MEMORY WILL BE GET CHANGED.

a = 100
b = 123.234
c = 12-23j
d = True
e = 'Python'

# before the modification

print(id(a),id(b),id(c),id(d),id(e))
print(a,b,c,d,e)

# a = 140733395174936
# b = 2061537095280
# c = 2061540524592
# d = 140733394379152
# e = 140733394059536

a = 1000
b = 0.0021e-27
c = 1222-2334j
d = False
e = 'abcde'

# after modification

print(id(a),id(b),id(c),id(d),id(e))
print(a,b,c,d,e)


MUTABILITY
==========
AFTER THE DEFINITION, THE DATA CAN BE ALLOWED FOR THE MODIFICATION. 
AND THE MODIFICATION ON DATA IS POSSIBLE WITHIN THE SAME MEMORY ADDRESS.
EX: LIST, SETS, DICTIONARY ETC.

a = [1,3,5,7,9]     # list
b = {11,12,13,14,15}    # set
c = {'a' : 123,'b' : 121, 'c' : 222}    # dictionary

# before the change

print(id(a))
print(id(b))
print(id(c))

print(a,b,c)

a[2] = 97
b.add(123)
c['d'] = 129779

print(id(a))
print(id(b))
print(id(c))

print(a,b,c)

===================================================================

COLLECTION DATATYPES
=======================
==> THE VARIABLE CAN BE DEFINED WITH MORE THAN ON E VALUE
==> THE DIFFERENT COLLECTION DATATYPES ARE:
	1) SEQUENTIAL DATATYPES
		==> LIKE STRINGS, THESE ARE ALSO INDEX BASED AND OREDRED.
		==> THERE ARE TWO SEQUENTIAL DATATYPES:
			1) LIST DATATYPE
			2) TUPLE DATATYPE
	2) NON SEQUENTIAL DATATYPES
		==> NOT DEPENDING WITH INDEX BUT MAY OR MAY NOT BE ORDERED.
		==> ARE CLASSIFIED INTO:
			1) SET TYPE ==> {} 
				i) SETS
				ii) FROZEN SETS
			2) MAP TYPE ==> KEY AND VALUE PAIR FORMAT
				i) DICTIONARY 
			3) BYTE TYPE ==> 0 TO 255
				i) BYTES
				ii) BYTEARRAY



1) LIST DATATYPE
================
==> LIST DATA CAN ALWAYS BE DEFINED WITH ==> []
==> LIST IS COLLECTION OF HOMOGENEOUS ELEMENTS AND HETEROGENEOUS ELEMENTS
HOMOGENEOUS ==> ALL VALUES OF LIST ==> SAME TYPE
HETERGENEOUS ==> THE DIFFERENT TYPES OF IETEMS ARE JOINED
==> THE LIST ELEMENTS IN [] MUST BE SEPARATED WITH COMMA
EX: [1,2,3,5]
==> LIST DATATYPE ==> INBUILT DATATYPE
	CLASS ==> list
==> LIST IS ORDERED.
==> LIST IS INDEX BASED
	WE CAN ALLOWED TO ACCESS THE INDIVIDUAL ELEMENTS OF A LIST WITH POSITIVE INDEX AND WITH NEGATIVE INDEX
	WE CAN ALLOWED TO ACCESS THE PART OF THE LIST USING SLICING
==> LIST MUTABLE DATATYPE.
==> LIST CAN BE DUPLICATED.

# homogeneous list

ld1 = [1,3,5,7,9]   # a list with decimals
ld2 = [0b11001,0o112233,0x112233, 1234] # list with integers
ld3 = [11.12,1.23e-2,22.334]    # list with floats

ld4 = [11,12.23e-8,True,12-23j,'abcd']      # hetergeneous list

print(type(ld1),type(ld2),type(ld3),type(ld4))

print(ld1)
print(ld2)
print(ld3)
print(ld4)

print(ld1[0],ld1[1],ld1[2],ld1[3],ld1[4])   # positive indexing
print(ld1[-1],ld1[-2],ld1[-3],ld1[-4],ld1[-5])  # negative indexing
print(ld1[::-1])
print(ld2[::-1])

print(id(ld1))
ld1[3] = 97
print(ld1)
print(id(ld1))

===========================================

2) TUPLE DATATYPE
==================
==> the sequence of values can be represented within () with the comma separation ==> tuple data definition.
==> tuple can be homogeneous
==> tuple can be heterogeneous
==> tuple is ordered
==> tuple is index based
==> tuple can be duplicated.
==> tuple can be immutable.

a = (1,2,3,4,5,6,7) # homogeneous tuple
b = (11,0.0097, True, 12-23j,'abcd')    # heterogeneous tuple
c = (1,1,3,5,7,9,1,3,3,5,7,9)

print("a = ",a)
print("b = ",b)     # ordered.

print(a[0],a[1],a[2],a[3],a[4],a[5],a[6])   # positive indexing
print(a[-1],a[-2],a[-3],a[-4],a[-5],a[-6],a[-7])    # negative indexing

print(b[1:5:1])
print(b[::-1])

print(c)
print(id(c))
# c[0] = 9797
print(c)
print(id(c))