Variables and Data Types Of Python

 1. Variables:

Variables are used to store data values. In Python, variables are created when you assign a value to them. Unlike some other programming languages, you don't need to declare the variable type explicitly; Python infers the data type based on the assigned value.

Example:

x = 10 # Integer variable y = 3.14 # Float variable name = "John" # String variable is_student = True # Boolean variable

In this example:

• x is an integer variable storing the value 10.
• y is a float variable storing the value 3.14.
• name is a string variable storing the value "John".
• is_student is a boolean variable storing the value True.

2. Data Types:

Python supports several built-in data types, each designed to represent different kinds of data. Here are some common data types in Python:

a. Numeric Types:

• int: Represents integer values, e.g., 10, -5, 1000.
• float: Represents floating-point (decimal) values, e.g., 3.14, 2.5, 1.0.

b. String Type:

• str: Represents sequences of characters enclosed within single (') or double (") quotes, e.g., "Hello", 'Python', "123".

c. Boolean Type:

• bool: Represents Boolean values True or False.

d. Sequence Types:

• list: Represents ordered collections of items, which can be of different data types and mutable (modifiable), e.g., [1, 2, 3], ['a', 'b', 'c'].
• tuple: Represents ordered collections of items, similar to lists but immutable (cannot be modified), e.g., (1, 2, 3), ('a', 'b', 'c').
• range: Represents sequences of numbers, commonly used for looping, e.g., range(5) generates numbers from 0 to 4.

e. Mapping Type:

• dict: Represents collections of key-value pairs, where each key is associated with a value, e.g., {'name': 'John', 'age': 30}.

f. Set Types:

• set: Represents unordered collections of unique items, e.g., {1, 2, 3}.
• frozenset: Similar to sets but immutable.

g. None Type:

• NoneType: Represents the absence of a value, commonly used to indicate null or undefined values, e.g., None.

Example:

# Numeric types x = 10 # int y = 3.14 # float # String type name = "John" # str # Boolean type is_student = True # bool # Sequence types my_list = [1, 2, 3] # list my_tuple = (4, 5, 6) # tuple my_range = range(5) # range # Mapping type my_dict = {'name': 'John', 'age': 30} # dict # Set types my_set = {1, 2, 3} # set my_frozenset = frozenset({4, 5, 6}) # frozenset # None type value = None # NoneType

Understanding variables and data types is fundamental in Python programming, as they form the building blocks for writing and manipulating data in your programs.

here's an example demonstrating variables and different data types in Python:

# Integer variable

age = 25

# Float variable

height = 5.11

# String variable

name = "John Doe"

# Boolean variable

is_student = True

# List variable

fruits = ['apple', 'banana', 'orange']

# Tuple variable

coordinates = (10, 20)

# Dictionary variable

person = {'name': 'Alice', 'age': 30, 'is_student': False}

# Set variable

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

# None variable

no_value = None

# Printing the values and their types

print("Age:", age, "Type:", type(age))

print("Height:", height, "Type:", type(height))

print("Name:", name, "Type:", type(name))

print("Is Student:", is_student, "Type:", type(is_student))

print("Fruits:", fruits, "Type:", type(fruits))

print("Coordinates:", coordinates, "Type:", type(coordinates))

print("Person:", person, "Type:", type(person))

print("Unique Numbers:", unique_numbers, "Type:", type(unique_numbers))

print("No Value:", no_value, "Type:", type(no_value))

When you run this code, you'll see output similar to the following:

Age: 25 Type: <class 'int'>

Height: 5.11 Type: <class 'float'>

Name: John Doe Type: <class 'str'>

Is Student: True Type: <class 'bool'>

Fruits: ['apple', 'banana', 'orange'] Type: <class 'list'>

Coordinates: (10, 20) Type: <class 'tuple'>

Person: {'name': 'Alice', 'age': 30, 'is_student': False} Type: <class 'dict'>

Unique Numbers: {1, 2, 3, 4, 5} Type: <class 'set'>

No Value: None Type: <class 'NoneType'>

This example demonstrates various data types in Python, including integers, floats, strings, booleans, lists, tuples, dictionaries, sets, and the None type. Understanding these data types and how to work with them is essential for effective Python programming.