# Example 1: Absolute value of a complex number
x = abs(1 + 2j)
print(x)
# Output: 2.23606797749979
# Explanation: sqrt(1**2 + 2**2) = sqrt(1 + 4) = sqrt(5)

# Example 2: Absolute value of a negative float
x = abs(-2.50)
print(x)
# Output: 2.5
# Explanation: Converts negative number to positive

# Example 1: Check if all feature values are normalized (between 0 and 1)
features = [0.8, 0.5, 0.95, 1.0]
are_all_normalized = all(0 <= x <= 1 for x in features)
print(are_all_normalized)
# Output: True
# Explanation: All values fall within the 0-1 normalization range

# Example 2: Check if all model predictions are greater than a threshold
predictions = {0.92, 0.87, 0.89, 0.95}
threshold = 0.85
is_confident = all(p > threshold for p in predictions)
print(is_confident)
# Output: True
# Explanation: Every prediction exceeds the confidence threshold

# Example 3: Check for missing values in dataset (0 represents missing)
data_row = [1, 1, 0, True]
is_valid_row = all(data_row)
print(is_valid_row)
# Output: False
# Explanation: The row contains a missing or invalid (0) value

# Example 4: Dictionary with feature presence (keys)
features_present = {1: "age", 2: "income", 0: "education"}
check_all_present = all(features_present)
print(check_all_present)
# Output: False
# Explanation: Key '0' evaluates to False, so not all features are present

# Example 5: Empty input vector
empty_vector = ()
check_empty = all(empty_vector)
print(check_empty)
# Output: True
# Explanation: By definition, all() returns True for empty iterables

# Example 1: Check if any input features are missing (0 indicates missing)
input_vector = [1, 0, 1, 1]
has_missing = any(x == 0 for x in input_vector)
print(has_missing)
# Output: True
# Explanation: At least one feature is marked as missing (0)

# Example 2: Identify if any prediction scores fall below a safe threshold
model_outputs = [0.92, 0.88, 0.76, 0.95]
threshold = 0.80
any_low_confidence = any(score < threshold for score in model_outputs)
print(any_low_confidence)
# Output: True
# Explanation: One of the predictions is below the defined threshold

# Example 3: Dictionary with encoded feature flags (keys)
feature_flags = {0: "inactive", 1: "active"}
any_active_flag = any(feature_flags)
print(any_active_flag)
# Output: True
# Explanation: Key '1' is truthy, so `any()` returns True

# Example 4: Check if any model evaluation metric is perfect
metrics = (0.9, 1.0, 0.85)
has_perfect_score = any(m == 1.0 for m in metrics)
print(has_perfect_score)
# Output: True
# Explanation: A perfect score (1.0) exists in the tuple

# Example 5: Empty input check
empty_input = {}
x = any(empty_input)
print(x)
# Output: False
# Explanation: No elements to evaluate, so returns False

# Example : String containing non-ASCII characters
text = "Model trained by Ståle on dataset µData"
ascii_output = ascii(text)
print(ascii_output)
# Output: 'Model trained by St\xe5le on dataset \xb5Data'
# Explanation: Non-ASCII characters like 'å' and 'µ' are escaped in ASCII-safe form

num = 36
binary_value = bin(num)

print(binary_value)
# Output: '0b100100'
# Explanation: The integer 36 is represented as '100100' in binary,
# and the '0b' prefix signifies that it's a binary number.

# Example 1: Non-zero integer
x = bool(1)
print(x)
# Output: True

# Example 2: Empty list
x = bool([])
print(x)
# Output: False

# Example 3: None value
x = bool(None)
print(x)
# Output: False

# Example 1: Create a bytearray of length 4 (all bytes initialized to zero)
x = bytearray(4)
print(x)
# Output: bytearray(b'\x00\x00\x00\x00')
# Explanation: Returns a bytearray of 4 bytes, each initialized to zero.

# Example 2: Create a bytearray from a string using UTF-8 encoding
text = "intensity"
x = bytearray(text, "utf-8")
print(x)
# Output: bytearray(b'intensity')
# Explanation: Each character in the string is converted to its UTF-8 byte representation.

# Example 3: Modify a byte in the bytearray
x[0] = 73  # Replace 'i' (ASCII 105) with 'I' (ASCII 73)
print(x)
# Output: bytearray(b'Intensity')

# Example 1: Create an empty bytes object of size 4
x = bytes(4)
print(x)
# Output: b'\x00\x00\x00\x00'
# Explanation: Generates 4 bytes initialized to zero (immutable).

# Example 2: Convert a string to bytes using UTF-8 encoding
text = "intensity"
x = bytes(text, "utf-8")
print(x)
# Output: b'intensity'

# Example 3: Convert a list of integers to a bytes object
x = bytes([73, 110, 116])
print(x)
# Output: b'Int'
# Explanation: The integers represent ASCII values of characters.

# Example 1: Check if a user-defined function is callable
def example_function():
    return "This is callable!"

print(callable(example_function))
# Output: True
# Explanation: Functions can be called, so this returns True.

# Example 2: Check if an integer is callable
number = 10
print(callable(number))
# Output: False
# Explanation: Integers are not callable objects.

# Example 3: Check if a class instance is callable (with __call__)
class CallableObject:
    def __call__(self):
        print("I can be called like a function.")

obj = CallableObject()
print(callable(obj))
# Output: True
# Explanation: The object defines __call__, so it's callable.

# Example 1: Convert Unicode code point 97 to character
char = chr(97)
print(char)
# Output: a
# Explanation: Unicode 97 corresponds to the lowercase letter 'a'.

# Example 2: Convert multiple Unicode points
print(chr(65))   # Output: A
print(chr(8364)) # Output: €
print(chr(128512)) # Output: 😀

# Example 3: Invalid Unicode code point (out of range)
try:
    print(chr(1114112))  # Just beyond the Unicode limit
except ValueError as e:
    print("Error:", e)
# Output: Error: chr() arg not in range(0x110000)

class IntensityLogger:
    log_entries = []  # Class-level attribute shared across all instances

    def __init__(self, message):
        self.message = message

    @classmethod
    def log(cls, message):
        cls.log_entries.append(message)  # Accesses class attribute
        print(f"[CLASS LOG] {message}")

# Calling the class method using the class
IntensityLogger.log("Tutorial started.")
# Output: [CLASS LOG] Tutorial started.

# Accessing the shared log across instances
print(IntensityLogger.log_entries)
# Output: ['Tutorial started.']

### Creating a Class Method Without a Decorator

class IntensityCounter:
    count = 0

    def increase(cls):
        cls.count += 1
        print("Increased:", cls.count)

# Convert the regular method into a class method
IntensityCounter.increase = classmethod(IntensityCounter.increase)

# Call it
IntensityCounter.increase()
# Output: Increased: 1

# Example 1: Using `compile()` with `eval` mode
# Compiles a single expression and evaluates it
x = compile('55 + 10', 'test', 'eval')
result = eval(x)
print(result)
# Output: 65

# Example 2: Using `compile()` with `exec` mode
# Compiles multiple statements and executes them
code_block = '''
print("Executing block...")
x = 5 * 3
print("Result:", x)
'''
compiled_code = compile(code_block, 'demo', 'exec')
exec(compiled_code)
# Output:
# Executing block...
# Result: 15

#Example 3: One-liner using `exec`
x = compile('print(60)', 'script', 'exec')
exec(x)
# Output: 60

#Example 1: Using two numeric values

# Create a complex number with real part 3 and imaginary part 5
x = complex(1, 2)
print(x)
# Output: (1+2j)

# Example 2: Using a string representation
# Create a complex number from a string
x = complex('1+2j')
print(x)
# Output: (1+2j)

#Example 3: Omitting the imaginary part
# Only real part provided, imaginary defaults to 0
x = complex(4)
print(x)
# Output: (4+0j)

# Define a class with multiple attributes
class Person:
    name = "Alice"
    age = 30
    country = "Canada"

# Delete the 'age' attribute from the class
delattr(Person, 'age')

# Check if the attribute still exists
print(hasattr(Person, 'age'))
# Output: False
# Explanation: The 'age' attribute has been removed from the class

# Define a class and initialize attributes
class User:
    def __init__(self):
        self.username = "intensity_writer"
        self.role = "ML Author"

# Create an object of the User class
u = User()

# Remove the 'role' attribute from the object
delattr(u, 'role')

# Verify that the attribute is removed
print(hasattr(u, 'role'))
# Output: False
# Explanation: 'role' no longer exists in the object instance

# Example 1: Creating a Dictionary with Keyword Arguments

# Creating a dictionary using keyword arguments
person_info = dict(name="Raj", age=40, country="India")

print(person_info)
# Output: {'name': 'Raj', 'age': 40, 'country': 'India'}

# Example 2: Using `dict()` with a List of Tuples

# Creating a dictionary from a list of tuples
params = dict([("learning_rate", 0.01), ("batch_size", 32)])

print(params)
# Output: {'learning_rate': 0.01, 'batch_size': 32}

# Define a simple class with some attributes
class ModelConfig:
    model_name = "RandomForest"
    n_estimators = 100
    max_depth = 10

# Use dir() to inspect available attributes and methods
print(dir(ModelConfig))

# Output (partial, varies by environment):
# ['__class__', '__delattr__', ..., 'max_depth', 'model_name', 'n_estimators']

# Use divmod to divide 9 by 4
result = divmod(9, 4)

# Display the result
print(result)

# Output:
# (2, 1)

# Define a tuple
layers = ('Input 1', 'Input 2', 'Input 3', 'Input 4', 'Input 5')

# Use enumerate to index
indexed_layers = enumerate(layers)

# Convert to list and print the result
print(list(indexed_layers))

# Output:
# [(0, 'Input 1'), (1, 'Input 2'), (2, 'Input 3'), (3, 'Input 4'), (4, 'Input 5')]

# Define a dictionary of hyperparameters
params = {
    "learning_rate": 0.01,
    "epochs": 10,
    "batch_size": 32
}

# Expression to calculate total steps dynamically
expr = "(epochs * 5000) // batch_size"

# Use eval() with params as the local context
total_steps = eval(expr, {}, params)

print("Total training steps:", total_steps)

# Output:
# Total training steps: 1562

# Explanation:
# eval() computed the number of training steps based on given parameters.

# Define code block as a string (simulating dynamic input)
code_block = """
learning_rate = 0.001
epochs = 5
print("Training will run for", epochs, "epochs at LR =", learning_rate)
"""

# Execute the code
exec(code_block)

# Output:
# Training will run for 5 epochs at LR = 0.001

# Explanation:
# The exec() function executes the multi-line string as Python code.

# Sample dataset of candidate ages
candidate_ages = [15, 12, 17, 18, 25, 36]

# Define filtering logic: Accept only those aged 18 or older
def is_eligible(age):
    return age >= 18

# Apply filter to the list
eligible_candidates = filter(is_eligible, candidate_ages)

# Convert the result to a list and print
print(list(eligible_candidates))

# Output:
# [18, 25, 36]

# Convert an integer into a floating-point number
int_val = 5
float_val = float(int_val)
print(float_val)
# Output:
# 5.0

# Convert a numeric string into a float
string_val = "5.300"
float_val_str = float(string_val)
print(float_val_str)
# Output:
# 5.3

# Format a floating-point value as a percentage
confidence_score = 0.85
formatted_confidence = format(confidence_score, '%')
print(formatted_confidence)
# Output:
# 85.000000%

# Format an integer to hexadecimal
user_id = 255
hex_user_id = format(user_id, 'x')
print(hex_user_id)
# Output:
# ff

# Format a large number with comma separator (for better readability in reports)
total_parameters = 12345678
formatted_params = format(total_parameters, ',')
print(formatted_params)
# Output:
# 12,345,678

# Sample input
feature_tags = ['deep_learning', 'transformer', 'attention', 'transformer', 'nlp']

# Create an immutable version of feature tags
immutable_tags = frozenset(feature_tags)

# Output the frozen set
print("Frozen feature tags:", immutable_tags)

# Attempt to modify the frozenset (this will raise an error)
# immutable_tags.add('reinforcement_learning')  # Uncommenting this line will cause an AttributeError

# Output:
# Frozen feature tags: frozenset({'attention', 'nlp', 'transformer', 'deep_learning'})

# Example 1: Fetching a Valid Attribute

# Define a simple configuration class for an AI model
class ModelConfig:
    model_name = "BERT"
    version = "v1.0"
    task = "text-classification"

# Retrieve an existing attribute
model_task = getattr(ModelConfig, 'task')
print("Model Task:", model_task)

# Output:
# Model Task: text-classification

# Example 2: Retrieving a Non-Existing Attribute with Default Fallback**

# Trying to access a non-existing attribute 'dropout'
# Provide default value to avoid error

dropout_value = getattr(ModelConfig, 'dropout', 'not configured')
print("Dropout:", dropout_value)

# Output:
# Dropout: not configured

# Example 1: View Global Symbol Table

# Global variable used in model setup
model_name = "TransformerXL"

# Retrieve the global symbol table
global_scope = globals()

# Access the value of a global variable using its name
print("Model Name:", global_scope["model_name"])

# Output:
# Model Name: TransformerXL

# Example 2: Check for Script Metadata in Globals

# Print special script-related global variables
globals_dict = globals()

# Check if script metadata like '__name__' exists
print("__name__:", globals_dict["__name__"])

# Output:
# __name__: __main__

# Define a simple class representing a student
class Student:
    name = "Alice"
    age = 20

# Check if the Student class has certain attributes
print(hasattr(Student, 'name'))   # True - because 'name' exists
print(hasattr(Student, 'grade'))  # False - 'grade' is not defined

# Output:
# True
# False

# Example 1: Hash a String

# Get hash value of a string
string_name = "Deep learning"
print(hash(string_name))

# Output: Varies depending on Python session

# Example 2: Hash a Tuple

# Hash a tuple (must contain only hashable elements)
coordinates = (10, 20)
print(hash(coordinates))

# Output: Varies each session but consistent during runtime

# Example 3: Hash in Dictionary

# Define a configuration ID using a tuple as a key
model_config = {
    ("resnet", 50): "ImageNet ResNet-50",
    ("transformer", 12): "BERT Base"
}

# Access a value using a tuple key (hash internally used)
print(model_config[("resnet", 50)])

# Output:
# ImageNet ResNet-50

# Example 2: Help on a Custom Function

# Define a custom function
def greet(name):
    """Returns a greeting message."""
    return f"Hello, {name}!"

# Get help documentation
help(greet)

# Output:
# Help on function greet in module __main__:
# greet(name)
#    Returns a greeting message.

# Convert 16 to hexadecimal
value = 16
hex_value = hex(value)
print(f"The hexadecimal form of {value} is: {hex_value}")

# Output:
# The hexadecimal form of 16 is: 0x10

# Create two variables pointing to the same list
a = [1, 2, 3]
b = a

# Compare their memory addresses
print(id(a))  # Example: 140093760517952
print(id(b))  # Same as above since both point to the same list

# Output: 'a' and 'b' reference the same object in memory.

# Example 1: Simple Name Prompt

# Ask the user to enter their name
user_name = input("What is your name? ")

# Greet the user using their input
print("Welcome to Intensity Coding, " + user_name + "!")

# Example Output (if user enters "Aditi"):
# What is your name? Aditi
# Welcome to Intensity Coding, Aditi!

# Example 2: Convert Input to Integer for Age Calculation

# Prompt user to enter their age
age_input = input("Enter your age: ")

# Convert input from string to integer
age = int(age_input)

# Use the age in a simple calculation
print("In 5 years, you will be", age + 5)

# Example Output (if user enters "25"):
# Enter your age: 25
# In 5 years, you will be 30

# Example 1: Convert Float to Integer
# Convert a float to an integer
num = int(7.9)

print(num)
# Output:
# 7

# Example 2: Convert String to Integer
# Convert a numeric string to an integer
str_num = "45"
converted = int(str_num)

print(converted)
# Output:
# 45

# Example 3: Convert Binary String Using Base

# Convert binary (base 2) string to integer
binary_str = "1010"
result = int(binary_str, 2)

print(result)
# Output:
# 10
# Explanation: '1010' in binary = 10 in decimal

# Example 1: Basic Type Check

# Check if a number is an integer
num = 47
print(isinstance(num, int))  # Output: True

# Example 2: Check Against Multiple Types

# Check if a value matches any of the listed types
value = "Intensity"
result = isinstance(value, (str, int, list))
print(result)  # Output: True

# Example 3: Check Custom Class Instance

# Define a class
class ModelConfig:
    model_type = "Transformer"
    layers = 12

# Create an instance
config = ModelConfig()

# Check if config is an instance of ModelConfig
print(isinstance(config, ModelConfig))  # Output: True

# Example 4: Invalid Type Check

# Check if a float is an instance of list
value = 3.14
print(isinstance(value, list))  # Output: False

# Example 1: Basic Subclass Check

# Base class
class BaseModel:
    pass

# Derived class
class CustomModel(BaseModel):
    pass

# Check if CustomModel is a subclass of BaseModel
print(issubclass(CustomModel, BaseModel))  # Output: True

# Example 2: Check With Unrelated Classes

class Dataset:
    pass

class Trainer:
    pass

print(issubclass(Trainer, Dataset))  # Output: False

# Example 3: Using Tuple of Classes

class A: pass
class B: pass
class C(A): pass

# Check if class C is a subclass of either A or B
print(issubclass(C, (A, B)))  # Output: True

# Example 1: Creating an iterator from a list

# Create an iterable list
fruits_name = ["apple", "mango", "banana"]

# Convert the list into an iterator
fruit_iterator = iter(fruits_name)

# Retrieve elements one by one using next()
print(next(fruit_iterator))  # Output: apple
print(next(fruit_iterator))  # Output: mango
print(next(fruit_iterator))  # Output: banana

# Example 2: Using iter() with a sentinel value

# Define a callable object (function that returns user input)
def input_reader():
    return input("Enter a number (type 'exit' to stop): ")

# Create an iterator that ends when 'exit' is returned
input_iter = iter(input_reader, 'exit')

# Process the input until the sentinel is reached
for val in input_iter:
    print("You entered:", val)

# Example Input:
# Enter a number (type 'exit' to stop): 123
# You entered: 123
# Enter a number (type 'exit' to stop): 99
# You entered: 99
# Enter a number (type 'exit' to stop): exit

# Example 1: Length of a string

# String input
message = "Welcome to Intensity Coding"

# Get number of characters in the string
length = len(message)
print(length)
# Output: 27

# Example 2: Length of a list

topics = ["NLP", "Computer Vision", "Reinforcement Learning", "Generative Models"]

# Get number of items in the list
count = len(topics)
print(count)
# Output: 4

# Example 3: Length of a dictionary

# Dictionary containing model names
models = {
    "CNN": "Image classification",
    "RNN": "Sequence modeling",
    "Transformer": "Language tasks"
}

# Get number of key-value pairs
print(len(models))
# Output: 3

# Example 1: Convert a tuple to a list

topics = ('NLP', 'Vision', 'GANs')
topics_list = list(topics)
print(topics_list)
# Output: ['NLP', 'Vision', 'GANs']

# Example 2: Create a list from a string

text = "AI"
result = list(text)
print(result)
# Output: ['A', 'I']

# Example 3: Create an empty list

model_configs = list()
print(model_configs)
# Output: []

# Example 1: Get local variables in the current scope

# Define a function to simulate a local scope
def ai_info():
    model = "Transformer"
    version = 4
    config = {"layers": 12, "dropout": 0.1}

    # Fetch local symbol table
    local_vars = locals()
    print(local_vars)

# Call the function
ai_info()

# Output (example):
# {'model': 'Transformer', 'version': 4, 'config': {'layers': 12, 'dropout': 0.1}}
# Explanation: Returns all local variables as key-value pairs.

# Example 1: Get lengths of model names

# Define a function to calculate length
def get_length(item):
    return len(item)

# List of model names
models = ['GPT', 'BERT', 'Transformer']

# Apply function to each element using map
result = map(get_length, models)

# Convert the map object to list
print(result)
print(list(result))

# Output: [3, 4, 11]
# Explanation: Returns the length of each string in the list.

# Example 2: Combine two sets

# Function to combine strings
def combine(a, b):
    return f"{a}-{b}"

# Two iterables
models = ['GPT', 'BERT', 'T5']
tasks = ['NLP', 'QA', 'Summarization']

# Use map to pair each model with a task
result = map(combine, models, tasks)

# Convert to list
print(list(result))

# Output: ['GPT-NLP', 'BERT-QA', 'T5-Summarization']
# Explanation: Combines corresponding elements from both iterables.

# Example 1: Find maximum among numeric values

# Compare two numbers directly
result = max(15, 10)
print(result)

# Output: 15

# Example 2: Find max value in a tuple

scores = (12, 44, 31, 78)

# Get highest score
result = max(scores)
print(result)

# Output: 78

# Example 3: Max from strings (alphabetical comparison)

# Compare string values
names = ["Raj", "Dev", "Virat"]

# Find alphabetically last name
result = max(names)
print(result)

# Output: Virat

# Example 1: Create a memory view from bytes

# Create a bytes object
data = b"Intensity"

# Get a memoryview of the bytes
mem_view = memoryview(data)

print(mem_view)       # Output: <memory at 0x...>
print(mem_view[0])    # Output: 73 -> ASCII of 'I'
print(mem_view[1])    # Output: 110 -> ASCII of 'n'

# Example 2: Modify bytearray using memoryview

# Create a mutable bytearray
buffer = bytearray(b"AI")

# Create a memoryview of it
view = memoryview(buffer)

# Modify the first byte (replace 'A' -> 'B')
view[0] = 66    # 66 is ASCII of 'B'

print(buffer)   # Output: bytearray(b'BI')

# Example 3: Slice and inspect memory

# Create a memoryview over a bytearray
buffer = bytearray(b"coding")

view = memoryview(buffer)

# Slice the memoryview and convert to bytes
sub_view = view[1:5]
print(bytes(sub_view))  # Output: b"odin"

# Example 1: Finding the smallest number

x = min(5, 15, 2, 8)
print(x)
# Output: 2

# Example 2: Using min() on strings

# Alphabetical comparison - finds the smallest based on lexicographical order
names = ["Zara", "Liam", "Ava", "Noah"]
x = min(names)
print(x)
# Output: 'Ava' (since 'A' comes before others alphabetically)

# Example 3: min() with a tuple of numbers

# Tuple input
scores = (22, 45, 19, 88)
lowest = min(scores)
print(lowest)
# Output: 19

# Example 4: Using key argument for custom comparison

# Find the shortest string using key=len
models = ["ResNet", "GPT", "EfficientNet", "VGG"]
shortest_name = min(models, key=len)
print(shortest_name)
# Output: 'GPT'

# Example 1: Basic Usage with iter()

# Create an iterator from a list of AI model names
models = iter(["GPT", "BERT", "T5"])

# Manually access each element using next()
print(next(models))  # Output: GPT
print(next(models))  # Output: BERT
print(next(models))  # Output: T5

# Example 2: Using next() with a default fallback value

# List of data types used in ML
types = iter(["Tensor", "Array", "Matrix"])

# Access items and provide a default for when the list is exhausted
print(next(types, "None"))  # Output: Tensor
print(next(types, "None"))  # Output: Array
print(next(types, "None"))  # Output: Matrix
print(next(types, "None"))  # Output: None (since all elements are already consumed)

# Example 3: Avoiding `StopIteration` in AI Data Stream

# Simulating batch data from a generator
def data_stream():
    yield "Batch 1"
    yield "Batch 2"

stream = data_stream()

# Safe access using next() with default
print(next(stream, "No more data"))  # Output: Batch 1
print(next(stream, "No more data"))  # Output: Batch 2
print(next(stream, "No more data"))  # Output: No more data

# Example 1: Creating and Inspecting an `object` Instance

# Creating an empty object using object()
empty = object()

# View all built-in attributes and methods inherited from base object
print(dir(empty))

# Output: ['__class__', '__delattr__', '__dir__', '__doc__', ..., '__str__', '__subclasshook__']
# Explanation: These are the default attributes every Python object has.

# Example 2: Attempting to Add Attributes (Fails)

# Trying to add attributes to a base object
obj = object()

# This will raise an AttributeError since object() is immutable and doesn't allow setting attributes
try:
    obj.name = "AI Model"
except AttributeError as e:
    print("Error:", e)

# Output:
# Error: 'object' object has no attribute 'name'

# Example 3: Base Class for Inheritance

# Define a custom class inheriting from base object explicitly
class ModelConfig(object):
    def __init__(self):
        self.name = "Transformer"
        self.layers = 12

config = ModelConfig()
print(config.name)   # Output: Transformer
print(config.layers) # Output: 12

# Example 1: Convert Decimal to Octal

# Convert a decimal number to its octal representation
number = 15
octal_value = oct(number)

print(octal_value)
# Output: 0o17

# Example 1: Reading a File (Basic Read Mode)

# Open and read a text file using default 'rt' mode (read text)
with open("intensity.txt", "r") as file:
    content = file.read()
    print(content)

# Output:
# (Displays content of intensity.txt if it exists)

# Example 4: Binary File Handling (Binary Read Mode)

# Open an image file in binary mode
with open("intensity.png", "rb") as image_file:
    binary_data = image_file.read()
    print(type(binary_data))

# Output:
# <class 'bytes'>

# Example 1: Convert a Lowercase Letter to Unicode

# Get the Unicode value of the character 'i'
x = ord("i")
print(x)

# Output:
# 105

# Example 2: Unicode of a Special Symbol

# Get the Unicode code point of the dollar sign
symbol_code = ord("$")
print(symbol_code)

# Output:
# 36

# Example 3: Unicode of a Non-English Character

# Get Unicode value of a non-English letter
char_code = ord("अ")  # Hindi letter 'A'
print(char_code)

# Output:
# 2309