Datatypes in Python----------------------------------------------------------------

Python data types are actually classes, and the defined variables are their instances or objects. Since
Python is dynamically typed, the data type of a variable is determined at runtime based on the assigned
value.

In general, the data types are used to define the type of a variable. It represents the type of data we are
going to store in a variable and determines what operations can be done on it.

Each programming language has its own classification of data items. With these datatypes, we can store
different types of data values.

Types of Data Types in Python

Python supports the following built-in data types −

Numeric Data Types

o int
o flot
o complex

String Data Types

Sequence Data Types

o list
o tuple
o range

Dictionary Data Type

Set Data Type

Boolean Data Type

1. Python Numeric Data Types

Python numeric data types store numeric values. Number objects are created when you assign a value to
them. For example −

var1 = 1#int data type

var2 = 10.023# float data type
var3 = 10+3j# complex data type
Following is an example to show the usage of Integer, Float and Complex numbers:
# integer variable.
a=100
print("The type of variable having value", a, " is ", type(a))

# float variable. c=20.345

print("The type of variable having value", c, " is ", type(c))

# complex variable. d=10+3j

print("The type of variable having value", d, " is ", type(d))

2. Python String Data Type

Python string is a sequence of one or more Unicode characters, enclosed in single, double or triple
quotation marks (also called inverted commas). Python strings are immutable which means when you
perform an operation on strings, you always produce a new string object of the same type, rather than
mutating an existing string.

As long as the same sequence of characters is enclosed, single or double or triple quotes don't matter.
Hence, following string representations are equivalent.

>>> 'PTRSU'
' PTRSU '
>>> “PTRSU "
' PTRSU '
>>> ''' PTRSU '''
' PTRSU '

A string is a non-numeric data type. Obviously, we cannot perform arithmetic operations on it.
However, operations such as slicing and concatenation can be done. Python's str class defines a number
of useful methods for string processing. Subsets of strings can be taken using the slice operator ([ ] and
[:] ) with indexes starting at 0 in the beginning of the string.

The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator in
Python.

str = 'Hello World!'

print (str)# Prints complete string

print (str[0]) # Prints first character of the string

print (str[2:5]) # Prints characters starting from 3rd to 5 th

 print (str[:2]) # Prints string starting from 3rd character

print (str * 2) # Prints string two times

print (str + "TEST") # Prints concatenated string

This will produce the following result −

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

3. Python Sequence Data Types

Sequence is a collection data type. It is an ordered collection of items. Items in the sequence have a
positional index starting with 0. It is conceptually similar to an array in C or C++. There are following
three sequence data types defined in Python.

 List Data Type

 Tuple Data Type
 Range Data Type

(a) Python List Data Type

Python Lists are the most versatile compound data types. A Python list contains items separated by
commas and enclosed within square brackets ([]). To some extent, Python lists are similar to arrays in
C. One difference between them is that all the items belonging to a Python list can be of different data
type where as C array can store elements related to a particular data type.(Mutable)

>>> [2023, "Python", 3.11, 5+6j, 1.23E-4]

A list in Python is an object of list class. We can check it with type() function.

>>> type([2023, "Python", 3.11, 5+6j, 1.23E-4])

<class 'list'>

As mentioned, an item in the list may be of any data type. It means that a list object can also be an item
in another list. In that case, it becomes a nested list.

>>> [['One', 'Two', 'Three'], [1,2,3], [1.0, 2.0, 3.0]]

A list can have items which are simple numbers, strings, tuple, dictionary, set or object of user defined
class also.
The values stored in a Python list can be accessed using the slice operator ([ ] and [:]) with indexes
starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list
concatenation operator, and the asterisk (*) is the repetition operator.

Example of List Data Type

Open Compiler

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print (list) # Prints complete list

print (list[0]) # Prints first element of the list
print (list[1:3]) # Prints elements starting from 2nd till 3rd
print (list[2:]) # Prints elements starting from 3rd element
print (tinylist * 2) # Prints list two times
print (list + tinylist) # Prints concatenated lists

This produce the following result −

['abcd', 786, 2.23, 'john', 70.2]

abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

(b) Python Tuple Data Type

Python tuple is another sequence data type that is similar to a list. A Python tuple consists of a number
of values separated by commas. Unlike lists, however, tuples are enclosed within parentheses (...).

A tuple is also a sequence, hence each item in the tuple has an index referring to its position in the
collection. The index starts from 0.

>>> (2023, "Python", 3.11, 5+6j, 1.23E-4)

In Python, a tuple is an object of tuple class. We can check it with the type() function.

>>> type((2023, "Python", 3.11, 5+6j, 1.23E-4))

<class 'tuple'>

As in case of a list, an item in the tuple may also be a list, a tuple itself or an object of any other Python
class.

>>> (['One', 'Two', 'Three'], 1,2.0,3, (1.0, 2.0, 3.0))

To form a tuple, use of parentheses is optional. Data items separated by comma without any enclosing
symbols are treated as a tuple by default.
>>> 2023, "Python", 3.11, 5+6j, 1.23E-4
(2023, 'Python', 3.11, (5+6j), 0.000123)

Example of Tuple data Type

Open Compiler

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')

print (tuple) # Prints the complete tuple

print (tuple[0]) # Prints first element of the tuple
print (tuple[1:3]) # Prints elements of the tuple starting from 2nd till 3rd
print (tuple[2:]) # Prints elements of the tuple starting from 3rd element
print (tinytuple * 2) # Prints the contents of the tuple twice
print (tuple + tinytuple) # Prints concatenated tuples

This produce the following result −

('abcd', 786, 2.23, 'john', 70.2)

abcd

(786, 2.23)

(2.23, 'john', 70.2)

(123, 'john', 123, 'john')

('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

The main differences between lists and tuples are: Lists are enclosed in brackets ( [ ] ) and their
elements and size can be changed i.e. lists are mutable, while tuples are enclosed in parentheses ( ( ) )
and cannot be updated (immutable). Tuples can be thought of as read-only lists.

The following code is invalid with tuple, because we attempted to update a tuple, which is not allowed.
Similar case is possible with lists −
Open Compiler

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # Invalid syntax with tuple
list[2] = 1000 # Valid syntax with list

(c) Python Range Data Type

A Python range is an immutable sequence of numbers which is typically used to iterate through a
specific number of items.
It is represented by the Range class. The constructor of this class accepts a sequence of numbers starting
from 0 and increments to 1 until it reaches a specified number. Following is the syntax of the function −

range(start, stop, step)

Here is the description of the parameters used −

start: Integer number to specify starting position, (Its optional, Default: 0)

stop: Integer number to specify ending position (It's mandatory)

step: Integer number to specify increment, (Its optional, Default: 1)

Example of Range Data Type

Following is a program which uses for loop to print number from 0 to 4 −

Open Compiler

for i in range(5):
print(i)

This produce the following result −

Now let's modify above program to print the number starting from 2 instead of 0 −
Open Compiler

for i in range(2, 5):

print(i)

This produce the following result −

2
3
4

Again, let's modify the program to print the number starting from 1 but with an increment of 2 instead
of 1:
Open Compiler
for i in range(1, 5, 2):
print(i)

This produce the following result −

1
3

range( ) without step:-

r=range(5)
print(list(r)) //[0,1,2,3,4]

range( ) with start, stop:-

r=range(2,8)
print(list(r)) //[2,3,4,5,6,7]

range( ) with start, stop,step:-

r=range(2,8,1)
print(list(r)) //[2,3,4,5,6,7]

range( ) with negative step:-

r=range(10,0,-1)
print(list(r)) //[10,9,8,7,6,5,4,3,2,1]

5. Python Dictionary Data Type

Python dictionaries are kind of hash table type. A dictionary key can be almost any Python type, but are
usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.

Python dictionary is like associative arrays or hashes found in Perl and consist of key:value pairs. The
pairs are separated by comma and put inside curly brackets {}. To establish mapping between key and
value, the semicolon':' symbol is put between the two.

>>> {1:'one', 2:'two', 3:'three'}

In Python, dictionary is an object of the built-in dict class. We can check it with the type() function.

>>> type({1:'one', 2:'two', 3:'three'})

<class 'dict'>

Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square
braces ([]).

Example of Dictionary Data Type

Open Compiler
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one']) # Prints value for 'one' key

print (dict[2]) # Prints value for 2 key
print (tinydict) # Prints complete dictionary
print (tinydict.keys()) # Prints all the keys
print (tinydict.values()) # Prints all the values

This produce the following result −

This is one

This is two

{'dept': 'sales', 'code': 6734, 'name': 'john'}

['dept', 'code', 'name']

['sales', 6734, 'john']

Python's dictionary is not a sequence. It is a collection of items but each item (key:value pair) is not
identified by positional index as in string, list or tuple. Hence, slicing operation cannot be done on a
dictionary. Dictionary is a mutable object, so it is possible to perform add, modify or delete actions with
corresponding functionality defined in dict class. These operations will be explained in a subsequent
chapter.

6. Python Set Data Type

Set is a Python implementation of set as defined in Mathematics. A set in Python is a collection, but is
not an indexed or ordered collection as string, list or tuple. An object cannot appear more than once in a
set, whereas in List and Tuple, same object can appear more than once.

Comma separated items in a set are put inside curly brackets or braces {}. Items in the set collection can
be of different data types.

>>> {2023, "Python", 3.11, 5+6j, 1.23E-4}

{(5+6j), 3.11, 0.000123, 'Python', 2023}

Note that items in the set collection may not follow the same order in which they are entered. The
position of items is optimized by Python to perform operations over set as defined in mathematics.

Python's Set is an object of built-in set class, as can be checked with the type() function.

>>> type({2023, "Python", 3.11, 5+6j, 1.23E-4})

<class 'set'>

A set can store only immutable objects such as number (int, float, complex or bool), string or tuple. If
you try to put a list or a dictionary in the set collection, Python raises a TypeError.

>>> {['One', 'Two', 'Three'], 1,2,3, (1.0, 2.0, 3.0)}

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Hashing is a mechanism in computer science which enables quicker searching of objects in computer's
memory. Only immutable objects are hashable.

Even if a set doesn't allow mutable items, the set itself is mutable. Hence, add/delete/update operations
are permitted on a set object, using the methods in built-in set class. Python also has a set of operators
to perform set manipulation. The methods and operators are explained in latter chapters

Example of Set
set1 = {123, 452, 5, 6}
set2 = {'Java', 'Python', 'JavaScript'}

print(set1)
print(set2)

This will generate the following output −

{123, 452, 5, 6}
{'Python', 'JavaScript', 'Java'}

Set operations:-union(|),intersection(&),difference(-),symmetric_difference(^)

7. Python Boolean Data Type

Python boolean type is one of built-in data types which represents one of the two values
either True or False. Python bool() function allows you to evaluate the value of any expression and
returns either True or False based on the expression.

A Boolean number has only two possible values, as represented by the keywords, True and False. They
correspond to integer 1 and 0 respectively.

>>> type (True)

<class 'bool'>
>>> type(False)
<class 'bool'>

Example of Boolean Data Type

Following is a program which prints the value of boolean variables a and b −

Open Compiler

a = True
# display the value of a
print(a)

# display the data type of a

print(type(a))

This will produce the following result −

true

<class 'bool'>

Following is another program which evaluates the expressions and prints the return values −
Open Compiler

# Returns false as a is not equal to b

a=2
b=4
print(bool(a==b))

# Following also prints the same

print(a==b)

# Returns False as a is None

a = None
print(bool(a))

# Returns false as a is an empty sequence

a = ()
print(bool(a))

# Returns false as a is 0
a = 0.0
print(bool(a))

# Returns false as a is 10
a = 10
print(bool(a))

This produce the following result −

False
False
False
False
False
True

Getting Data Type

To get the data types in Python, you can use the type() function. The type() is a built-in function that
returns the class of the given object.

Example

In the following example, we are getting the type of the values and variables −

Open Compiler

# Getting type of values

print(type(123))
print(type(9.99))

# Getting type of variables

a = 10
b = 2.12
c = "Hello"
d = (10, 20, 30)
e = [10, 20, 30]

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

This produce the following result −

<class 'int'>
<class 'float'>
<class 'int'>
<class 'float'>
<class 'str'>
<class 'tuple'>
<class 'list'>

Setting Data Type

In Python, during declaring a variable or an object, you don't need to set the data types. Data type is set
automatically based on the assigned value.
Example

The following example, demonstrating how a variable's data type is set based on the given value −

Open Compiler

# Declaring a variable
# And, assigning an integer value

x = 10

# Printing its value and type

print("x = ", x)
print("type of x = ", type(x))

# Now, assigning string value to

# the same variable
x = "Hello World!"

# Printing its value and type

print("x = ", x)
print("type of x = ", type(x))

This produce the following result −

x = 10

type of x = <class 'int'>

x = Hello World!

type of x = <class 'str'>

What is Statement in Python-----------------------------------------------------

A Python statement is an instruction that the Python interpreter can execute. There are different types
of statements in Python language as Assignment statements, Conditional statements, Looping
statements, etc. The token character NEWLINE is used to end a statement in Python. It signifies that
each line of a Python script contains a statement. These all help the user to get the required output.

Multi-line Statement in Python:

In Python, the statements are usually written in a single line and the last character of these lines is
newline. To extend the statement to one or more lines we can use braces {}, parentheses (), square [],
semi-colon “;”, and continuation character slash “\”. we can use any of these according to our
requirement in the code. With the line continuation character, we can explicitly divide a long statement
into numerous lines (\).
# Initialize the lines using continuation character
g = "hello\
dear\
student"
print(g)

hellodearstudent

Line continuation are divided into two different ways:

Explicit line continuation
Implicit line continuation

Using “\”(Explicit line continuation):

In this type of multi-line statement, we will be using the line continuation character (\) to split a
statement into multiple lines.
Example:
In this example, we are initializing the text, and the mathematical expression using the ‘\’ sign which is
the explicit line continuation to continue the same line in the multiple lines in python programming.

# Initializing a text using the

# Explicit multi-line statement.
text = "A Computer Science portal\
for xyz. It contains well written, well \
thought and well explained \
computer science and programming \
articles"
print('\n Initializing a text using\
the Explicit multi-line statement', text)

# Initializing a mathematical expression

# using the Explicit multi-line statement.
add = 50 + \
40 - \
52

print('\n Initializing a mathematical expression\

 using the Explicit multi-line statement', add)

Output:
Initializing a text using the Explicit multi-line statement A Computer Science portalfor xyz. It
contains well written, well thought and well explained computer science and programming articles

Initializing a mathematical expression using the Explicit multi-line statement 38

Using parenthesis (Implicit line continuation):

In this type of multi-line statement, Implicit line continuation is used when you split a statement using
either parenthesis ( ), brackets [ ], and braces { }.
Example:
In this example, we are initializing the list and the mathematical expression using the parentheses ( ),
brackets [ ], and braces { } sign which is the implicit line continuation to continue the same line in the
multiple lines in python programming.

# Initializing a string
# using parentheis "()".
g = (f" Hello"
f"dear"
f"Student")
print(g)

# Initializing a list using the

# Implicit multi-line statement.
list = [5,
4, 3, 2, 1
]

print()
print('Initializing a list using the\
Implicit multi-line statement', list)

# Initializing a mathematical expression

# using the Implicit multi-line statement.
add = (50 +
40 -
52)
print()
print('Initializing a mathematical expression\
using the Explicit multi-line statement', add)

Hellodearstudent

Initializing a list using the Implicit multi-line statement [5, 4, 3, 2, 1]

Initializing a mathematical expression using the Explicit multi-line statement 38

Using triple quote(line break)

Example:

# Initializing a string
# using triple qoute.
g = """hello
dear
student"""

print(g)
print()

Output
'hello\ndear\nstudent'

To remove \n:- s_no_newline = s.replace("\n", " ")

Note:-
 Multiline statement in inline :- a=10;print(a) //10.
 String statement:- print("Hello ‘shiv’") // Hello ‘shiv’

What is Indentation in Python---------------------------------------------------

In Python, indentation plays a crucial role in defining the structure of the code, particularly in blocks of
code like loops, conditionals, functions, and classes. Unlike some programming languages that use braces
({}) to define code blocks, Python relies entirely on indentation to define which lines of code belong to
which blocks.
 Expected Indent
 Unexpected Indent

1. Expected Indentation

Expected indentation occurs when Python expects an indented block after certain statements, like if, for,
while, def, class, etc. This is how Python knows where the block of code for that statement ends.

if True:

print("This is inside the if block") # Indentation is expected after an if statement

In the above code:

 After if True:, Python expects the code block that should be executed if the condition is true to be
indented.
 The line print("This is inside the if block") is indented correctly (by 4 spaces or a tab) and is part of
the if block.

2. Unexpected Indentation

Unexpected indentation happens when Python finds an indented line of code where it doesn't expect one,
causing a IndentationError. This typically occurs when you add unnecessary indentation or indent in the
wrong place.

if True:

print("This will cause an IndentationError")

In this example:

 The print statement should be indented after the if True: line to indicate it belongs to the if block.
 Since there is no indentation for print("This will cause an IndentationError"), Python raises an
IndentationError.