Store All Data Types

First, let’s list the data types supported in Python.

Python Supported Data Types

• Primitive Data Types:
  • Integer
  • Float
  • String
  • Boolean
  • None
• Non-Primitive Data Types:
  • List
  • Tuple
  • Set
  • Bytes and ByteArray
  • Complex
  • Class Object

Store and Experiment with All Data Types

phone = 1234567890
pi    = 3.14
name  = "python programming"
using_python   = True
example_none   = None
simple_list    = [1,2,3]
simple_dict    = {"name":"python"}
simple_set     = {1,1,1,1,1.0}
simple_tuple   = (1,2,3)
complex_number = 3+5j

print("number     = ",phone)
print("float      = ",pi)
print("boolean    = ",using_python)
print("None       = ",example_none)
print("list       = ",simple_list)
print("dictionary = ",simple_dict)
print("set        = ",simple_set)
print("tuple      = ",simple_tuple)
print("complex    = ",complex_number)

number     =  1234567890
float      =  3.14
boolean    =  True
None       =  None
list       =  [1, 2, 3]
dictionary =  {'name': 'python'}
set        =  {1}
tuple      =  (1, 2, 3)
complex    =  (3+5j)

print(type(phone))
print(type(pi))
print(type(using_python))
print(type(simple_list))
print(type(simple_dict))
print(type(simple_set))
print(type(simple_tuple))
print(type(complex_number))
print(type(example_none))

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'list'>
<class 'dict'>
<class 'set'>
<class 'tuple'>
<class 'complex'>
<class 'NoneType'>

Bytes and ByteArray

These data types help modify large binary datasets like audio and image processing.

The memoryview() function allows modifying this data without zero-copy access to memory.

bytes is immutable, where as bytearray is mutable.

bytes

b1 = bytes([1,2,3,4])
bo = memoryview(b1)
print("byte example :",bo[0])

byte example : 1

b2 = bytearray(b"aaaa")
bo = memoryview(b2)
print("byte array :",b2)
bo[1] = 98
bo[2] = 99
bo[3] = 100
print("byte array :",b2)

byte array : bytearray(b'aaaa')
byte array : bytearray(b'abcd')

test_frozenset = frozenset([1,2,1])
for i in test_frozenset:
    print("frozen set item :",i)

frozen set item : 1
frozen set item : 2

a = range(3)
print("a = ",a)
print("type = ",type(a))

a =  range(0, 3)
type =  <class 'range'>

value = 1
numbers = [1,2,3]
print("type casting int     : ",type(int(value)))
print("type casting float   : ",type(float(value)))
print("type casting string  : ",type(str(value)))
print("type casting boolean : ",type(bool("True")))
print("type casting list    : ",type(list(numbers)))
print("type casting set     : ",type(set(numbers)))
print("type casting tuple   : ",type(tuple(numbers)))

type casting int     :  <class 'int'>
type casting float   :  <class 'float'>
type casting string  :  <class 'str'>
type casting boolean :  <class 'bool'>
type casting list    :  <class 'list'>
type casting set     :  <class 'set'>
type casting tuple   :  <class 'tuple'>

temp = 1
print("temp variable is : ",temp)
del temp
# print(temp)  => throw NameError : temp not defined

temp variable is :  1

temp = "hi"
print("address of temp variable : ",id(temp))

address of temp variable :  140710894284672

from collections import namedtuple
const = namedtuple("const",["PI"])
math = const(3.14)

print("namedtuple PI = ",math.PI)
print("namedtuple type =",type(math))

namedtuple PI =  3.14
namedtuple type = <class '__main__.const'>

message = "Hi"
def dummy():
    global message 
    message = message+" all"

dummy()
print(message)

Hi all

They improve code readability and help developers understand variable types.

-> float : It indicates the return data type.

def area_of_circle(radius :float) -> float:
    PI :float = 3.14
    return PI * (radius * radius)

print("calculate area of circle = ",area_of_circle(2))

Output

calculate area of circle =  12.56

# Snapshots of the family's adventures
ooty_adventure = ("Ooty", "2024-07-01", "Visited Botanical Garden")
munnar_adventure = ("Munnar", "2023-12-15", "Saw Nilgiri Tahr in Eravikulam national park")
manjolai_adventure = ("Manjolai", "2023-05-21", "Enjoyed hill stations")

photo_album = [ooty_adventure, munnar_adventure, manjolai_adventure]

# Accessing elements in a tuple
location = ooty_adventure[0]
date = ooty_adventure[1]
description = ooty_adventure[2]

print(f"Location: {location}, Date: {date}, Description: {description}")

# output: Location: Ooty, Date: 2024-07-01, Description: Visited Botanical Garden

# Unpacking tuple
location, date, description = munnar_adventure
print(f"Location: {location}, Date: {date}, Description: {description}")

ooty_adventure[2] = "Visited Doddabeta Peak"

# Concatenating tuples
combined_adventure = ooty_adventure + munnar_adventure
print(combined_adventure)

# Repeating tuples
repeated_adventure = manjolai_adventure * 2
print(repeated_adventure)

# Checking membership
is_ooty_in_album = ooty_adventure in photo_album
is_munnar_in_album = munnar_adventure in photo_album

print(f"Is the Ooty adventure in the album? {is_ooty_in_album}")
print(f"Is the Munnar adventure in the album? {is_munnar_in_album}")

# Finding length of the tuple
number_of_adventures = len(photo_album)
print(f"Number of adventures in the album: {number_of_adventures}")
# Output: Number of adventures in the album: 3