DATATYPES:
==========
PRIMITIVE DATATYPES:
	1) NUMERICAL DATATYPES
		INTEGER, FLOAT, COMPLEX
	2) NON-NUMERICAL DATATYPES
		THE VARIABLE WITH NON-DIGIT VALUES
		ex: An Application form:
			eligibility to vote: Yes (True)
			marital status: No (False)
		==> Boolean Datatype
			pre-defined class: bool
			has only two value:
				True, False
		==> Python has 35 keywords:
			out of 35, there are three values we can define as keywords
				True, False, None (Capitalize case)
			except these three remaining all the keywords must be defined with lower case alphabets only.
		==> Boolean data internally can decode:
			True ===> 1
			False ===> 0
		==> On Boolean data, we can define some Math operations like:
			addition, subtraction etc.

a = True
b = False

print(type(a))
print(type(b))

print(a)
print(b)

print(a+b)
print(a-b)
print(a*b)
# print(a/b)
print(b/a)
	
	3) TEXT BASED DATATYPES

VARIABLE:
=========
	A NAMED MEMORY/CONATINER
		USED TO STORE A VALUE OF ANY TYPE.
DYNAMICALLY TYPED PROGRAMMING LANGUAGE
	THE DATA AND ITS TYPE CAN BE UNDERSTOOD/DECODED BY THE PVM (PYTHON VIRTUAL MACHINE) / PYTHON INTERPRETER BASED ON THE ASSIGNMENT OF THE VALUE AUTOMATICALLY.
	ONCE WE HAVE DEFINED, THIS CAN BE GET MODIFIED/REDEFINED/REASSIGNED AGAIN AND AGAIN.

a = 100
print(type(a))	==> int

a = 123.234
print(type(a))	==> float

a = 12-23j
print(type(a))	==> complex

==========================================
TEXT BASED DATATYPE:
====================
==> CALLED AS "STRING" DATATYPE.
==> STRING IS GROUP OF CHARACTERS/SEQUENCE OF CHARACTERS WHICH ENCLOSED WITH SINGLE QUOTES OR DOUBLE QUOTES.
EX: 'PYTHON', "Python" ETC.
Note:
====
If a string has start to define with single quote, it must be with end/terminate with single quote only.
If a string has start with double quote and should end with double quote.
'python" ==> Syntax error

==> Pre-defined/Inbuilt datatype
	class : str
==> Like other languages,
	in python, there is no character data representation.
In java:
	char ch = 'a';
In python, the character data definition also considered as "string type".

STRINGS ARE SEQUENTIAL/ORDERED:
===============================
INDEX BASED
===========
==> THAT EACH CHARACTER OF THE STRING CAN BE DENOTED WITH SOME INTEGER NUMBER, WHICH CAN USE TO ACCESS THE INDIVIDUAL CHARACTERS OF THE STRING IN EITHER FORWARD DIRECTION/FORWARD ACCESS OR REVERSE DIRECTION/REVERSE ACCESS.
==> TWO DIFFERENT TYPES OF INDEX REPRESENTATIONS:
	1) POSITIVE INDEXING
	=====================
		THE START INDEX ==> 0 (DEFAULT VALUE)
		THE LAST INDEX ==> NUMBER_CHARACTERS - 1
		RANGE OF INDEX ==> 0 TO NUM_CHARACTERS - 1
		==> USING THIS RANGE OF INDEX:
			WE CAN ACCESS THE INDIVIDUAL CHARACTERS OF THE STRING FROM LEFT TO RIGHT ==> FORWARD ACCESS.
		Syntax:
			str_data_object[index value]
	2) NEGATIVE INDEXING
	=====================
		THE START INDEX ===> -1 (DEFAULT VALUE)
		THE LAST INDEX ===> -NUM_CHAR
		RANGE : -1 TO -NUM_CHARS
		==> USING THIS:
			WE CAN ACCESS THE INDIVIDUAL CHARACTERS FROM RIGHT TO LEFT
				==> REVERSE ACCESS.
		Syntax:
			str_obj[-index value]

STRING CAN BE SLICED
====================
ACCESSING OF THE PART OF STRING ===> STRING SLICING
Syntax:
	str_obj[start:stop]
here:
	start ==> is the index which represents the starting point of the slicing
	stop ==> is the index which represents the end point of the slicing.
		PVM/Interpreter:
			always consider the less '1' from the stop 

Note:
====
	start and stop values are optional in slicing syntax.
	Syntax:
		str[:stop] ==> the slicing should start from first character by default.
		str[start:] ==> the slicing should end with last character by default.	
		str[:] ==> slicing should start with "first" character and end with "last".

==> String slicing is also possible with three values
	Syntax:
		str[start:stop:step]
Here:
	step ==> difference between current index and next immediate index

Note:
====
Start index < stop

data = "Python Programming"

print(data)

print(data[0:6])
print(data[-18:-12])
print(data[:6])
print(data[6])
print(data[7:18])
print(data[7:])
print(data[-11:])
print()

print(data[:])
print()

print(data[0:18:3])
print(data[::4])
print(data[-18::5])
print(data[::-1])

print(data[10:1:-1])
print(data[-1:-18:-1])