Python Data Types

Data types are the classification or categorization of data

items. Python supports the following built-in data types.
Scalar Types
 int: Positive or negative whole numbers (without a
fractional part) e.g. -10, 10, 456, 4654654.
 float: Any real number with a floating-point
representation in which a fractional component is
denoted by a decimal symbol or scientific notation e.g.
1.23, 3.4556789e2.
 complex: A number with a real and imaginary
component represented as x + 2y.
 bool: Data with one of two built-in values True or False.
Notice that 'T' and 'F' are capital. true and false are not
valid booleans and Python will throw an error for them.
 None: The None represents the null object in Python.
A None is returned by functions that don't explicitly
return a value.
Sequence Type
A sequence is an ordered collection of similar or different
data types. Python has the following built-in sequence data
types:
 String: A string value is a collection of one or more
characters put in single, double or triple quotes.
 List: A list object is an ordered collection of one or more
data items, not necessarily of the same type, put in square
brackets.
  Tuple: A Tuple object is an ordered collection of one or
more data items, not necessarily of the same type, put in
parentheses.
Mapping Type
Dictionary: A dictionary Dict() object is an unordered
collection of data in a key:value pair form. A collection of
such pairs is enclosed in curly brackets. For
example: {1:"Steve", 2:"Bill", 3:"Ram", 4: "Farha"}
Set Types
 set: Set is mutable, unordered collection of distinct
hashable objects. The set is a Python implementation of
the set in Mathematics. A set object has suitable methods
to perform mathematical set operations like union,
intersection, difference, etc.
 frozenset: Frozenset is immutable version of set whose
elements are added from other iterables.
Mutable and Immutable Types
Data objects of the above types are stored in a computer's
memory for processing. Some of these values can be
modified during processing, but contents of others can't be
altered once they are created in the memory.
Numbers, strings, and Tuples are immutable, which means
their contents can't be altered after creation.
On the other hand, items in a List or Dictionary object can be
modified. It is possible to add, delete, insert, and rearrange
items in a list or dictionary. Hence, they are mutable objects.
Built-in Data Types in Python
Built-in data types in Python are fundamental data structures
provided by the Python programming language. They are pre-
defined and available for use without requiring any additional
libraries or modules. Python offers several built-in data types,
including:
Numeric Data Types: Numeric data types in Python are used
to represent numerical values. Python provides three primary
numeric data types:
Integer (int): Integers are whole numbers without any
decimal points. They can be positive or negative.
Floating-Point (float): Floating-point numbers represent
decimal values. They can be positive or negative and may
contain a decimal point.
Complex (complex): Complex numbers are used to represent
numbers with a real and imaginary part. They are written in
the form of a + bj, where a is the real part and b is the
imaginary part.
String Data Type(str): Represents a sequence of characters
enclosed in single quotes (‘ ‘) or double quotes (” “), such as
“Hello, World!”, ‘Python’.
Boolean Data Type(bool): Represents either True or False,
used for logical operations and conditions.
Collection Data Types:
list: Represents an ordered and mutable collection of items,
enclosed in square brackets ([]).
tuple: Represents an ordered and immutable collection of
items, enclosed in parentheses ().
dict: Represents a collection of key-value pairs enclosed in
curly braces ({}) with unique keys.
set: Represents an unordered and mutable collection of unique
elements, enclosed in curly braces ({}) or using the set()
function.

Numeric Data Types

Numeric data types in Python are used to represent numerical
values. Python provides three primary numeric data types –
integer (int), floating-Point (float) and complex (complex).
These numeric data types allow for performing various
arithmetic operations, such as addition, subtraction,
multiplication, and division. They provide the necessary
flexibility to work with numerical data in Python programs.
Int – It stores the integers values that can be positive or
negative and do not contain any decimal point. Example:
num1=10, num2 = 15
Float – These are floating-point real numbers that stores the
decimal values. It consists of integer and fraction parts.
Example: fnum = 25.4, fnum1=67.8
Complex – These are complex numbers specified as a real
part and an imaginary part. They are stored in the form of a +
bj where a is the real part and j represents the imaginary part.
Example: num3= 2 + 3j, numcom = 5 – 7j
Python Code:

Integers (int)
Python’s integer data type (int) represents whole numbers
without any decimal points. It stores positive and negative
whole numbers. Integers are immutable, meaning their value
cannot be changed once assigned.
Example 1
# Assigning integer values to variables

x=5

y = -10

# Performing arithmetic operations

sum_result = x + y

difference_result = x - y

multiplication_result = x * y

division_result = x / y
# Printing the results

print("Sum:", sum_result)

print("Difference:", difference_result)

print("Multiplication:", multiplication_result)

print("Division:", division_result)
Output:
Sum: -5

Difference: 15

Multiplication: -50

Division: -0.5
Example 2
# Using integer values in comparisons

a = 10

b = 20
# Comparing the values

greater_than = a > b

less_than_or_equal = a <= b

equal_to = a == b

not_equal_to = a != b

# Printing the results

print("Greater than:", greater_than)

print("Less than or equal to:", less_than_or_equal)

print("Equal to:", equal_to)

print("Not equal to:", not_equal_to)

Output:
Greater than: False
Less than or equal to: True

Equal to: False

Not equal to: True

Floating-Point Numbers (float)
The float data type in Python is used to represent floating-
point numbers, which are numbers with decimal points. Floats
are used when more precision is needed than what integers
can provide. Floats are immutable like integers and follow the
IEEE 754 standard for representing real numbers.
Example 1
# Assigning float values to variables

x = 3.14

y = 2.5

# Performing arithmetic operations

sum_result = x + y

difference_result = x - y
multiplication_result = x * y

division_result = x / y

# Printing the results

print("Sum:", sum_result)

print("Difference:", difference_result)

print("Multiplication:", multiplication_result)

print("Division:", division_result)
Output:
Sum: 5.64

Difference: 0.64

Multiplication: 7.85

Division: 1.256
Example 2
# Using float values in comparisons
a = 1.2

b = 2.7

# Comparing the values

greater_than = a > b

less_than_or_equal = a <= b

equal_to = a == b

not_equal_to = a != b

# Printing the results

print("Greater than:", greater_than)

print("Less than or equal to:", less_than_or_equal)

print("Equal to:", equal_to)

print("Not equal to:", not_equal_to)
Output:
Greater than: False

Less than or equal to: True

Equal to: False

Not equal to: True

Complex Numbers (complex)
The complex data type in Python is used to represent numbers
with both real and imaginary parts. It is written in the form of
a + bj, where a represents the real part and b represents the
imaginary part. Complex numbers are useful in mathematical
calculations and scientific computations that involve
imaginary quantities.
Example 1
# Assigning complex values to variables

x = 2 + 3j

y = -1 + 2j

# Performing arithmetic operations

sum_result = x + y

difference_result = x - y

multiplication_result = x * y

division_result = x / y

# Printing the results

print("Sum:", sum_result)

print("Difference:", difference_result)

print("Multiplication:", multiplication_result)

print("Division:", division_result)
Output:
Sum: (1+5j)

Difference: (3+1j)
Multiplication: (-8+1j)

Division: (0.8-1.4j)
Example 2
# Using complex values in comparisons

a = 1 + 2j

b = 3 + 4j

# Comparing the values

equal_to = a == b

not_equal_to = a != b

# Printing the results

print("Equal to:", equal_to)

print("Not equal to:", not_equal_to)

Output:
Equal to: False
Not equal to: True
Textual Data Types – Strings
Textual data types in Python are used to represent and
manipulate sequences of characters, such as words, sentences,
or even larger blocks of text. The primary textual data type in
Python is the string (str). Strings are enclosed in quotes (‘ ‘, ”
“, or “”” “””) and can be manipulated using various string
methods. They are immutable, meaning their values cannot be
changed once assigned. String data types are commonly used
for tasks like text processing, input/output operations, and
data manipulation.
Accessing String Values
Each character of a string can be expressed with the help of a
technique called indexing. In indexing, each character has an
index value represented by either a positive or negative
integer starting from 0.
Syntax:- stringname[index]
Example
Str1=”Python
#accessing second character
Str1[1]
#accessing first four characters
Str1[0:4] # it will print the value from index 0 to 3
str1="Python"
>>> str1[1]
'y'
>>> str1[0:4]
'Pyth'
Positive indexing 0 1 2 3 4 5
String P y t h o n
Negative indexing -6 -5 -4 -3 -2 -1
String Operations
1) Concatenation – Python allows us to join two different
strings using the concatenation operator ‘+’
Syntax:– str1 + str2
Example
>>> str1="Analytic"
>>> str2="Vidya"
>>> str3=str1 +str2
>>> print(str3)
AnalyticVidya
2) Repetitions – Python allows us to repeat a given string
with the help of ‘ * ‘ operator.
Syntax:– stringname * integervalue
Example
>>> str2 = "python"
>>> str2 * 3
'pythonpythonpython'
3) Membership – The Membership operator helps to check
whether a given character is present in the string or not with
the help of two operators in and not in. In and not in operator
returns the boolean value True or False.
Syntax:– character in/not in stringname
Example
>>> str1="python"
>>> "p" in str1
True
>>> "f" in str1
False
Built-in Functions in String
1) Len() – It is used to calculate the length of the given string.
Syntax:– len(stringname)
Example
>>> str1="Python"
>>> len(str1)
6
2) isupper() – This function is used to check whether all the
letters in a string are in the upper case or not. If all the
characters are in upper case then it returns True otherwise it
returns False.
Syntax:– stringname.isupper()
Example
>>>str1= " Hello Everyone"
>>> str1.isupper()
False
>>> str2="HELLO"
>>> str2.isupper()
True
3) islower() – This function is used to check whether all the
letters in a string are in lowercase or not. If all the characters
are in lower case then it returns True otherwise it returns
False.
Syntax:– stringname.islower()
Example
>>> s="hello"
>>> s.islower()
True
>>> s1="hey Folks!"
>>> s1.islower()
False
4) upper() – It is used to convert all the characters of a string
in uppercase.
Syntax:– stringname.upper()
Example
>>>str1= " Hello Everyone"
>>> str1.upper()
' HELLO EVERYONE'
5) lower() – It is used to convert all the characters of a string
in lowercase.
Syntax:– stringname.lower ()
Example
>>> str2="HELLO"
>>> str2.lower()
'hello'
Boolean Data Type
The boolean data type in Python represents logical values of
True and False. It is used to evaluate conditions and make
logical decisions in a program. Booleans are the result of
comparisons and logical operations.
Example 1
# Logical operations with booleans

a = True

b = False

result_and = a and b

result_or = a or b
result_not = not a

print(result_and)

print(result_or)

print(result_not)
Output:
False

True

False
Example 2
# Comparisons using booleans

x=5

y = 10

greater_than = x > y

less_than_or_equal = x <= y
equal_to = x == y

not_equal_to = x != y

print(greater_than)

print(less_than_or_equal)

print(equal_to)

print(not_equal_to)
Output:
False

True

False

True
Collection Data Types
Collection data types in Python are used to store and organize
multiple values into a single entity. Python provides several
built-in collection data types, including lists, tuples,
dictionaries, and sets.
Lists (list)
The list data type in Python is used to store multiple items in a
single variable. Lists are ordered, mutable, and can contain
elements of different data types. They are created by
enclosing comma-separated values within square brackets [ ].
Example 1
List1=[123,567,89] #list of numbers
List2=[“hello”,”how”,”are”] #list of strings
List3= [“hey”,1223,”hello”] #list of mixed data type.
Accessing Elements of the List
Elements of the list are accessed in the same as that of string
that is with the help of positive and negative indexing. Slicing
is also used to access the list elements in which more than a
single element is accessed at a time.
List1=[“apple”,123,”mango”,[2,3,4,]]
Positive index 0 1 2 3
List “apple” 123 “mango” [2,3,4]
Negative
-4 -3 -2 -1
index
Example
>>> list1=['apple',123,"mango",[2,3,4,]]
>>> list1[0]
'apple'
>>> list1[3]
[2, 3, 4]
>>> list1[1:3]
[123, 'mango']
Operations in List
1) Concatenation – Two lists are concatenated with the help
of “+” operator.
Syntax:- list1 + list2
>>> list1=["apple","mango",123,345]
>>> list2 = ["grapes"]
>>> list1 + list2
['apple', 'mango', 123, 345, 'grapes']
2) Repititions – With the help of the ‘ * ‘ operator list can be
repeated n number of times.
Syntax:- list1* number
>>> list1=["apple","mango",123,345]
>>> list1*2
['apple', 'mango', 123, 345, 'apple', 'mango', 123, 345]
3) Membership – ‘ in ‘and ‘ not in ‘ are two membership
operators that are used to check whether the given element is
present in the list or not and return a Boolean value True or
False.
Syntax:– element in/not in in list1
>>> list1=["apple","mango",123,345]
>>> 'apple' in list1
True
>>> 'apple' not in list1
False
Built-in functions in the list
1) append() – This function is used to add a single element at
the end of the list. The single element that is added can be of
any data type like integer, list, string, etc.
Syntax :- listname.append(element)
>>> list1=["apple","mango","grapes",123,345]
>>> list1.append("orange")
>>> list1
['apple', 'mango', 'grapes', 123, 345, 'orange']
>>> list1.append([12,34,55])
>>> list1
['apple', 'mango', 'grapes', 123, 345, 'orange', [12, 34, 55]]
2) insert() – insert() function is also used to add element in
this list but with the help of insert we can add the element at a
particular index in the list. If the index is not present then it
will add the element at the end of the list.
Syntax :- listname.insert (index,element)
>>> list2=["apple","mango","grapes",123,345]
>>> list2.insert(0,234)
>>> list2
[234, 'apple', 'mango', 'grapes', 123, 345]
>>> list2.insert(6,"papapa")
>>> list2
[234, 'apple', 'mango', 'grapes', 123, 345, 'papapa']
3) count() – count function is used to count the number of
time an element occurs in the list.
Syntax:– listname.count(element)
>>> list3=[12,45,12,67,78,90]
>>> list3.count(12)
2
>>> list3.count(11)
0
4) reverse() – reverse function is used to reverse the order of
elements in the list.
Syntax:– listname.reverse()
>>> list3=[12,45,12,67,78,90]
>>> list3.reverse()
>>> list3
[90, 78, 67, 12, 45, 12]
5) sort() – sort function is used to arrange the elements of the
list in ascending order. The function list must contain all the
elements in the same data type that is either integers or
strings.
Syntax:– listname.sort()
list4=["grapes","banana","apple","mango"]
>>> list4.sort()
>>> list4
['apple', 'banana', 'grapes', 'mango']
>>>list5=[12,45,12,67,78,90]
>>>list5.sort()
[12,12,45,67,78,90]
Dictionary
Dictionary is a special data type that is a mapping between a
set of keys and a set of values. It represents a key-value pair
enclosed in curly brackets and each element is separated by a
comma. Key-value pairs are separated by the colon. The
elements of the dictionaries are unordered and the key is
unique for each value in the dictionary. The elements of the
dictionary are mutable that is its elements can be changed
once it is created.
Syntax:- Dictionaryname={key:value}
Example
Dict1={“comp”: “computer” , “sci” : “science”}

Dict2={“123”:”computer”,456 : “maths”}
Accessing Elements of the Dictionary
The elements of the dictionary are accessed with the help of
the keys. Each key serves as an index and maps the value in
the dictionary.
Syntax:- dictionaryname[key]
>>> dict1={"comp": "computer" , "sci" : "science"}
>>> dict1["comp"]
'computer'
>>> dict1["sci"]
'science'
New elements are added in the dictionary with the help of a
new key.
>>> dict1={"comp": "computer" , "sci" : "science"}
>>> dict1["comm"]="commerce"
>>> dict1
{'comp': 'computer', 'sci': 'science', 'comm': 'commerce'}
Built-in Functions in the Dictionary
1) items() – items() function returns a list of tuples of key-
value pair of the dictionary.
Syntax:- dictionaryname.items()
>>> dict1={"comp": "computer" , "sci" :
"science","comm":"commerce"}
>>> dict1.items()
dict_items([('comp', 'computer'), ('sci', 'science'), ('comm',
'commerce')])
2) keys() – This function returns the list of keys in the
dictionary.
Syntax:- dictionaryname.keys()
>>> dict1={"comp": "computer" , "sci" :
"science","comm":"commerce"}
>>> dict1.keys()
dict_keys(['comp', 'sci', 'comm'])
3) values() – It returns the list of values in the dictionary.
Syntax:- dictionaryname.values()
>>> dict1={"comp": "computer" , "sci" :
"science","comm":"commerce"}
>>> dict1.values()
dict_values(['computer', 'science', 'commerce'])
4) len() – length function is used to count the total number of
elements in the dictionary.
Syntax:- len(dictionaryname)
>>> dict1={"comp": "computer" , "sci" :
"science","comm":"commerce"}
>>> len(dict1)
3
5) update() –it is used to append the key-value pair of the
dictionary passed as the argument to the key-value pair of the
given dictionary.
Syntax:- dictionary1.update(dictionary2)
>>> dict1={"comp": "computer" , "sci" :
"science","comm":"commerce"}
>>> dict2={"acc":"accounts","bst":"business studies"}
>>> dict1.update(dict2)
>>> dict1
{'comp': 'computer', 'sci': 'science', 'comm': 'commerce', 'acc':
'accounts', 'bst': 'business studies'}
Sets (set)
The set data type in Python is an unordered collection of
unique elements. It is used to store multiple items without any
duplicates. Sets are created by enclosing comma-separated
elements within curly braces { } or by using the set()
constructor.
Example: Set creation and accessing elements
# Creating a set

my_set = {1, 2, 3, 4, 5}

# Accessing elements

for element in my_set:

print(element)

# Checking membership

is_present = 3 in my_set
# Printing the results

print(my_set)

print(is_present)
Output:
1

{1, 2, 3, 4, 5}

True
Example 2: Set operations
# Set operations

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Union of sets

union = set1.union(set2)

# Intersection of sets

intersection = set1.intersection(set2)

# Difference of sets

difference = set1.difference(set2)

# Printing the results

print(union)

print(intersection)

print(difference)
Output:
Copy code

{1, 2, 3, 4, 5, 6, 7, 8}

{4, 5}

{1, 2, 3}
Tuples (tuple)
The tuple data type in Python is similar to a list but with one
crucial difference: tuples are immutable. Once created, the
elements in a tuple cannot be modified. Tuples are created by
enclosing comma-separated values within parentheses ( ).
Example: Tuple creation and accessing elements
# Creating a tuple

my_tuple = (1, 2, 3, 4, 5)

# Accessing elements by index

first_element = my_tuple[0]

last_element = my_tuple[-1]

# Slicing a tuple
subset = my_tuple[1:4]

# Printing the results

print(my_tuple)

print(first_element)

print(last_element)

print(subset)
Output:
(1, 2, 3, 4, 5)

(2, 3, 4)
Custom Data Types in Classes
In Python, classes provide a way to define custom data types.
Classes encapsulate data and methods, allowing for the
creation of objects with specific attributes and
behaviors.Classes serve as blueprints for creating objects.
They define the structure and behavior of objects, including
their attributes (data) and methods (functions). Objects are
instances of classes, and each object has its own unique state
and behavior.
Example: Creating a class and instantiating objects
# Defining a class

class Point:

def __init__(self, x, y):

self.x = x

self.y = y

# Creating objects

point1 = Point(2, 3)

point2 = Point(5, 7)

# Accessing object attributes

print(point1.x, point1.y)

print(point2.x, point2.y)
Output:
23

57
Example 2: Adding methods to a class
# Defining a class with methods

class Circle:

def __init__(self, radius):

self.radius = radius

def area(self):

return 3.14 * self.radius ** 2

# Creating an object and using methods

circle = Circle(5)

print(circle.area())
Output:
78.5
Conclusion
Python data types form the foundation of any Python
programming endeavor. Understanding and utilizing these
data types effectively is essential for developing robust and
efficient applications. By mastering the intricacies of Python
data types, you will have the necessary skills to tackle
complex programming challenges.
Numeric Functions
A numeric object of one type can be converted in another
type using the following functions:

Built-in Function Description

int Returns the integer object from a float or a
string containing digits.
float Returns a floating-point number object from
a number or string containing digits with
decimal point or scientific notation.
complex Returns a complex number with real and
imaginary components.
hex Converts a decimal integer into a
hexadecimal number with 0x prefix.
oct Converts a decimal integer in an octal
representation with 0o prefix.
pow Returns the power of the specified numbers.
abs Returns the absolute value of a number
without considering its sign.
round Returns the rounded number.