The AI driven business: Leading, Competing and Thriving in the Age of Artificial Intelligence

 

Introduction

Artificial Intelligence (AI) is no longer a speculative future-tech—it’s now a strategic imperative. Organizations that adopt AI effectively are gaining advantages in scale, efficiency, insight and innovation. But simply recognising AI’s importance isn’t enough. The real challenge for business leaders is how to lead, compete and thrive when AI changes the rules of business. This book offers a roadmap for that challenge: how to build an AI-driven enterprise, what mindset shifts are needed, what structures and capabilities matter, and how to stay competitive in a world where data, algorithms and automation increasingly define the field.

Why This Book Matters

• Strategic Relevance: Many businesses talk about “digital transformation” or “AI initiatives”, but struggle to align those with business value, leadership, organisational change, and competitive strategy. This book connects AI to leadership and competition.

• Holistic View: It emphasises that AI is not just a technology project—it’s a business transformation: how you lead, how you structure your organisation, how you compete, how you partner, how you evolve.

• Competitive Advantage: By exploring how companies succeed (and fail) with AI, the book gives leaders a vantage point for what winning looks like in the age of AI.

• Practical Frameworks: For readers—whether senior executives, strategy leads, or business managers—it gives frameworks, questions and pathways to apply AI thoughtfully rather than as hype.

• Leadership & Culture Focus: It emphasises you can’t just deploy algorithms—you also need to build culture, talent, strategic clarity, governance and organisational agility.

What the Book Covers

Here’s a thematic breakdown of the parts and major ideas you can expect:

Part I: The New Business Landscape

• How AI is shifting the boundaries of what businesses can do: scale, scope, learning.

• Why traditional competitive advantages (cost leadership, differentiation) are being supplemented or disrupted by AI-led capabilities.

• The emergence of new business models: data-driven platforms, network effects, algorithmic advantage.

Part II: Leadership for an AI-Driven Enterprise

• What leaders need to change: from intuition-driven decisions to data-&-algorithm enabled decisions.

• How to build organisations that learn, iterate and adapt using AI.

• Talent, culture and governance: hiring, reskilling, incentivising, ensuring ethical use of AI.

Part III: Operating Model & Execution

• How to structure your AI initiatives: pilot → scale, fusion of business + data + technology domains.

• Architecture, data infrastructure, platform thinking: building pipelines, managing data, deploying models.

• Metrics and measurement: how you judge success in AI initiatives, how you assess value beyond standard KPIs.

Part IV: Competing in an AI-First World

• How to identify where AI gives you real competitive advantage—not just cost savings, but new products, services, experiences.

• Strategic partnerships and ecosystems: no company works in isolation—AI often needs partnerships (data providers, platforms, AI vendors).

• Risk, ethics and governance: bias, transparency, compliance, trust—how companies must manage these to thrive.

Part V: Future-Ready Thinking

• What comes next: autonomous systems, agentic AI, self-optimising business processes.

• How companies keep ahead: continuous learning, agile operating models, redefining business boundaries, rethinking competition.

• The role of humans: even in an AI-driven world, human judgement, creativity, strategy and ethics will matter.

Who Should Read This Book?

• Senior leaders (CEOs, COOs, CIOs, Strategy Heads) who need to understand how to lead AI transformation—not just what the technology does.

• Business managers and transformation leads responsible for AI initiatives who want a strategic, organisational and technical mindset.

• Data & analytics leaders who need to tie AI projects to business impact and competitive strategy.

• Consultants, strategists and business students seeking to understand the evolving business model landscape in the AI era.
  If you are purely a hands-on AI practitioner (data scientist, ML engineer) wanting code-level detail, this book may be higher-level—but it will still provide essential context for business value and strategy.

How to Get the Most Out of It

• Read with your organisation in mind: As you read each chapter, reflect: How does this apply to my company? What’s our current AI capability? What’s missing in leadership, culture, infrastructure?

• Use the frameworks: The book may offer tools or questions—apply them to your business: audit your data, audit your talent, design your AI roadmap.

• Build a gap analysis: Identify where the company is strong/weak: e.g., data infrastructure, talent, culture, metrics, leadership alignment.

• Map to strategic initiatives: For each AI opportunity, map to business model, value proposition, competitive strategy; use the book’s frameworks to check alignment.

• Focus on change management: Recognise that AI initiatives fail often due to organisational and cultural issues, not tech. Use the insights to build culture & governance.

• Stay future-oriented: Don’t just focus on small AI wins—also think about what happens when AI scales, what new business boundaries emerge, how you stay ahead of competition.

Key Takeaways

• An AI-driven business is built not by isolated pilot projects but by scaling capability: data, algorithms, talent, culture, governance.

• Competitive advantage in the age of AI involves scale, scope and learning—you need to collect data, learn from feedback loops, adapt rapidly.

• Leadership and organisational structure must evolve: decisions become more data-/algorithm-based, talent must be organized differently, culture must support experimentation and learning.

• Focus less on “what the algorithm can do” and more on “what business problem will it solve, how will it change the business model, how will it change how we compete.”

• Ethics, trust, governance are no longer optional—they are central to thriving with AI. Companies that ignore these may face reputational risk, regulatory cost and competitive disadvantage.

• The future is not simply “AI replaces humans” but “AI augments humans”—businesses that leverage human + machine combination will thrive.

Hard Copy: The AI driven business: Leading, Competing and Thriving in the Age of Artificial Intelligence

Conclusion

“The AI Driven Business: Leading, Competing and Thriving in the Age of Artificial Intelligence” is an essential read for anyone who cares about how AI changes not just technology but business strategy, organisational design and competition. If you are in a role where you influence direction, build capability or decide on AI investment, this book gives you the perspective and frameworks to do so with depth and foresight.

Read More

Machine Learning with Python: Principles and Practical Techniques

 

Introduction

This book offers a balanced path into machine learning (ML) using Python—combining core principles (the “why” and “how” of algorithms) with practical techniques (the “what you can build” and “how you implement”). If you’re aiming to move beyond library-calls and want to understand both the theory behind ML and how to execute it in Python, this book is a strong candidate.

Whether you’re a data analyst, Python developer, or aspiring ML engineer, the book helps you bridge the gap between academic understanding and real-world application.

---

Why This Book Matters

• Theory + practice: Many ML resources focus heavily on one side—either theory (lots of math) or practice (lots of code). This book tries to balance both, letting you understand the foundations and then apply them.

• Python-centric: Python is the de facto language for ML/AI today. This book keeps things grounded in Python ecosystems, so you’ll work with tools and libraries you’ll likely use in real projects.

• Practical workflow orientation: Beyond algorithms, you’ll likely gain exposure to full workflows: data preparation, model building, evaluation, deployment—not just isolated examples.

• Better preparation for advanced work: If your ambition is to go deeper into ML (or even deep learning, or production ML systems), having a firm grip on both theory and technique is a huge plus.

---

What You’ll Learn

Here’s a breakdown of what to expect (in typical structure) and how each part contributes:

1. Foundations of Machine Learning

• Definitions: What is ML, how is it different from traditional programming, supervised vs unsupervised vs reinforcement learning.

• Mathematical background: You’ll likely revisit linear algebra, calculus, probability, statistics—since these underpin ML algorithms.

• Key concepts: Bias–variance trade-off, overfitting/underfitting, generalisation, model complexity.

2. Python Tools & Ecosystem

• Setting up your Python environment: libraries such as NumPy, Pandas, Matplotlib/Seaborn for data manipulation and visualisation.

• Using ML-specific libraries: e.g., scikit-learn (or equivalent) for algorithm implementation.

• Writing reusable code: structuring data pipelines, splitting train/test sets, evaluating models systematically.

3. Practical Techniques for Modeling

• Clean and prepare data: dealing with missing values, encoding categorical variables, feature scaling, feature selection.

• Building models: regression, classification, clustering algorithms. You’ll gain an understanding of when and how to pick algorithms.

• Evaluation & validation: metrics like accuracy, precision/recall, ROC-AUC, confusion matrix; cross-validation strategies.

• Tuning and optimisation: hyperparameter tuning, grid search/random search, handling real-world issues (imbalanced classes, noisy features).

4. Advanced Topics & Real-World Applications

• Ensemble methods: Bagging, boosting, random forests—how combining models can improve performance.

• Dimensionality reduction: techniques like PCA, feature extraction for high-dimensional data.

• Deploying models: exporting, versioning, integrating into systems or workflows—turning a model from prototype into production (depending on book coverage).

• Case studies: applying methods to real datasets, interpreting findings, dealing with messy data, business/industry context.

5. Build Your Own Practice Projects

• Work through example projects: end-to-end datasets, from data ingestion to model output and interpretation.

• Develop a personal portfolio: by following or adapting the book’s examples, you can build something you can show.

• Learn the mindset: how to approach new ML problems, document your workflow, interpret results, and think about improvements.

---

Who Should Read This Book?

• Python programmers or software developers wanting to move into machine learning or data science roles.

• Data analysts who use spreadsheets or analysis tools and want to extend into predictive modelling.

• Students or self-learners who have some background in math or programming and want a structured guide.

• Early-career ML engineers who know coding but want to strengthen their theory, workflows and best practices.

If you are entirely new to programming or have almost no mathematical background (especially in statistics/probability/linear algebra), you may need to supplement with a “math for ML” primer to get full benefit from the book.

---

How to Get the Most Out of It

• Code along: When the book gives examples, type them out rather than just reading. Change parameters or datasets to explore.

• Apply to your own data: After a chapter, pick your own small dataset (maybe from Kaggle or an open data portal) and try to apply what you’ve learned.

• Document your work: Keep a notebook (Jupyter) of what you did, what you changed, what worked/what didn’t. This becomes your portfolio.

• Review the math: When you encounter an algorithm’s mathematical explanation, pause and ensure you understand the key ideas (even if you skip some derivations).

• Iterate on projects: Once you finish one model, try improving it: add features, tune hyperparameters, use a different algorithm, evaluate again.

• Link theory to practice: Constantly ask “why” as well as “how”: Why did this algorithm behave this way? Why did the evaluation metric go up/down?

• Read with an eye to next steps: After finishing, think about what you’ll learn next—maybe deep learning, model deployment, or MLOps.

---

Key Takeaways

• Machine learning is not just running “library calls” — to use it well you need to understand data, algorithms, models, evaluation, and production workflows.

• A strong foundation in both principles (why algorithms behave as they do) and practical techniques (how to implement, evaluate, deploy) makes you a stronger ML practitioner.

• Python provides a terrific ecosystem—by mastering libraries and workflows in Python you position yourself for many real-world ML tasks.

• Building your own projects and portfolio helps you show your skills—not just read about them.

• The learning doesn’t stop with one book: use this book as a base and then move into advanced ML, deep learning or ML engineering domains.

---

Hard Copy: Machine Learning with Python: Principles and Practical Techniques

Conclusion

Machine Learning with Python: Principles and Practical Techniques is a valuable book for anyone serious about developing machine-learning capability—from theory, through modelling, to workflows and practical application. If you’re ready to commit to moving beyond surface-level ML tutorials into a deeper, more disciplined approach, this book offers a strong path.

Read More

Keras 3: Hands-On Deep Learning with Python, Neural Networks, CNNs, and Generative AI Models (Rheinwerk Computing)

 

Introduction

Deep learning continues to be one of the most powerful tools for building intelligent applications—whether in computer vision, natural language, generative modelling, or other domains. At the same time, frameworks like Keras have evolved rapidly, making it much easier for developers to implement complex models without getting lost in framework overhead. This book positions itself as a practical, up-to-date guide to the version Keras 3, guiding you from fundamentals into advanced neural-network architectures and generative AI systems—all using Python.

If you’re looking to bridge the gap between “I know how to write a small network” and “I can design, implement, tune and deploy modern deep-learning systems,” this book is tailored for you.

---

Why This Book Matters

• Coverage of Keras 3: Keras has moved beyond being just a TensorFlow front-end; version 3 brings enhancements, broader backend support and modern features. The book is timely in addressing these. 

• Hands-On Approach: Rather than only theory or high-level overviews, you’ll find code examples, project-driven workflows, real datasets and practical tips—making it actionable.

• Span of Topics: From basic neural networks through convolutional neural networks (CNNs), to sequence models, and further into generative modelling (autoencoders, GANs, diffusion) and advanced deep architectures. 

• Relevance for Developers & Practitioners: If your goal is not just to read about networks but to build and deploy them, this book gives you that bridge.

• Adding to Your Portfolio: Applying the book’s examples and adapting them gives you practical work you can show—important for roles in ML/AI engineering.

---

What the Book Covers

Here’s a breakdown of the major sections, themes and what you’ll learn:

1. Foundations of Deep Learning & Keras

You’ll start by understanding the landscape: what deep learning is, why neural networks work, what the Keras API offers, how to set up your environment (Python, GPU/TPU, libraries).
You’ll learn about tensors, layers, activations, losses, optimisers—building a solid ground so that when you move into deeper topics you’re comfortable. 

2. Building Basic Neural Networks

Moving from concept to code, the book walks you through constructing feed-forward neural networks for classification/regression tasks, training loops, tracking metrics, debugging under-/over-fitting, regularisation (dropout, batch norm) and feature engineering.
You’ll practice in Python and Keras, ensuring your fundamentals are hands-on.

3. Convolutional Neural Networks (CNNs)

A large section is devoted to CNNs—essential for image tasks. You’ll understand convolution operations, pooling, padding, architecture patterns (VGG, ResNet-style blocks), transfer learning and fine­tuning. You’ll build networks with Keras, learn how to adapt pre-trained models, and apply them to real image datasets.
Since Keras 3 supports modern features and simplifies workflows, this section is very practical.

4. Sequence Models & Advanced Architectures

The book then takes you into sequence data: RNNs, LSTMs, GRUs, attention mechanisms, transformers. You’ll learn how to process text, time-series, multi-modal data and how to build models with these architectures in Keras.
This section elevates your skills from “image only” to handling a broad set of AI tasks.

5. Generative AI Models

One of the most exciting parts: you’ll dive into generative modelling—how to build autoencoders, variational autoencoders (VAEs), generative adversarial networks (GANs) and even explore newer paradigms (depending on updates) like diffusion models or large generative networks. You’ll see how to generate images, translate styles, create synthetic data and wrap this into Keras workflows. 

6. Deployment, Production & Best Practices

The final sections often deal with moving models into production: saving/loading models, serving with APIs, optimising for latency/throughput, versioning models, monitoring performance, dealing with drift and data issues. The book may also cover how to build pipelines and integrate your Keras models into real-world applications.

7. Projects & Code Examples

Throughout, the book gives you practical, runnable code—Keras notebooks, project templates, datasets you can plug in and adapt. This means you’re not just reading but doing. The authors encourage you to experiment, adapt code, extend models and build your own mini-projects.

---

Who Should Read This Book?

• Developers and engineers with some Python experience (and preferably some ML basics) who want to specialize in deep learning and neural networks.

• Data scientists who already work with ML but want to upgrade to deeper architectures, generative models and production workflows.

• Students or researchers transitioning from classical ML into deep learning and generative AI.

• AI practitioners looking for a code-driven guide that bridges concept ↔ implementation in Keras.

If you are brand-new to programming or machine learning (no Python, no calculus/linear algebra), you might find early chapters manageable but later chapters more demanding. It helps if you are comfortable with Python, NumPy, basic ML and some math.

---

How to Get the Most Out of It

• Set up your environment early: Python 3, install Keras 3, ensure GPU/TPU support or use a cloud notebook.

• Code along: Whenever you see examples (layers, models, datasets, training loops), type them out, run them, tweak them. Change hyperparameters, modify architecture, use a different dataset.

• Build mini-projects: After each major topic (CNNs, sequence models, generative models), pick your own dataset or project idea. For example: build a style-transfer network, implement a simple chatbot, generate synthetic images.

• Connect theory and implementation: When reading about architecture patterns (e.g., residual blocks), pause and reflect: Why does this help? What problem does it solve? Then inspect code to see how it’s implemented.

• Experiment and extend: Don’t just replicate—ask “What if I double the layers? What if I change pooling? What if I replace one block with a transformer?” The book’s hands-on nature invites this.

• Focus on production readiness: When you reach deployment sections, think about how your model will serve in real life: latency, scalability, monitoring, data drift. Write code to save your model, deploy via a simple API, test it.

• Keep a portfolio: Save your project code, results, visualisations and upload to GitHub. Use notebooks to document what you did, what you changed and what you learned.

• Iterate over time: Deep learning evolves fast. Use the book as a foundation but revisit it later with new tools, frameworks or model families.

---

What You’ll Walk Away With

After completing this book and doing the exercises/projects, you should be able to:

• Confidently build neural networks in Keras 3 for a wide range of tasks: image classification, sequence modeling, generative modelling.

• Understand and implement CNNs, RNNs/transformers, autoencoders/GANs.

• Know how to fine-tune pre-trained models, deploy models in production, monitor performance and handle real-world issues.

• Move from using a library by copying examples to adapting and innovating with your own architectures and datasets.

• Possess a portfolio of hands-on projects that you can show to employers or use as a basis for further research.

• Be aware of the broader AI landscape—generative networks, transformer models, lifecycle of ML/AI systems—and ready to explore emerging trends.

---

Hard Copy: Keras 3: Hands-On Deep Learning with Python, Neural Networks, CNNs, and Generative AI Models (Rheinwerk Computing)

Conclusion

Keras 3: Hands-On Deep Learning with Python, Neural Networks, CNNs, and Generative AI Models is more than a book—it’s a practical roadmap for deep‐learning mastery. It doesn’t just tell you what to do; it shows you how to do it with code, projects, practical insights. For anyone serious about deep learning—developers, data scientists, machine learning engineers—this book offers the foundation and the tools to go from theory to deployment.

Read More

Python Coding challenge - Day 838| What is the output of the following Python Code?

Code Explanation:

1) Import the dataclass decorator

from dataclasses import dataclass

This imports the dataclass decorator from Python’s dataclasses module.

@dataclass automatically creates useful methods (like __init__) for classes.

2) Define the dataclass

@dataclass

class Marks:

@dataclass tells Python to turn Marks into a dataclass.

This means it will auto-generate an initializer (__init__) taking m1 and m2.

3) Declare fields of the class

    m1: int

    m2: int

These are the attributes of the class.

m1 and m2 are typed as integers, representing two marks.

4) Define a method to compute total

    def total(self):

        return (self.m1 + self.m2) // 2

total() is an instance method.

It adds the two marks and uses // 2 which performs integer division (floor division).

This returns the average of the two marks as an integer.

5) Create an object and print result

print(Marks(80, 90).total())

Marks(80, 90) creates an object with m1 = 80, m2 = 90.

.total() computes (80 + 90) // 2 = 170 // 2 = 85.

print() displays the result.

Final Output

85

600 Days Python Coding Challenges with Explanation

Read More

Python Coding challenge - Day 837| What is the output of the following Python Code?

Code Explanation:

1) Define the class

class Convert:

This starts the definition of a class named Convert.

A class groups related data (attributes) and behavior (methods).

2) Class attribute factor

    factor = 1.5

factor is a class variable (shared by the class and all its instances).

It’s set to the floating-point value 1.5.

You can access it as Convert.factor or cls.factor inside classmethods.

3) Mark the next method as a class method

    @classmethod

The @classmethod decorator makes the following method receive the class itself as the first argument (conventionally named cls) instead of an instance (self).

Class methods are used when a method needs to read/modify class state.

4) Define the apply class method

    def apply(cls, x):

        return x * cls.factor

apply takes two parameters: cls (the class object) and x (a value to process).

Inside the method, cls.factor looks up the class attribute factor.

The method returns the product of x and the class factor (i.e., x * 1.5).

5) Call the class method and convert to int

print(int(Convert.apply(12)))

Convert.apply(12) calls the class method with x = 12.

Calculation: 12 * 1.5 = 18.0.

int(...) converts the floating result 18.0 to the integer 18.

print(...) outputs that integer.

Final output

18

 

700 Days Python Coding Challenges with Explanation

Read More

7 Python Automation Scripts That Make Life Easier

1. Rename multiple files

 import os

files=["photo1.png","photo2.png","photo3.png"]
for i ,f in enumerate(files,start=1):
    new_name=f"image_{i}.png"
    print(f"Renamed{f} {new_name}")

Output:

Renamedphoto1.png image_1.png
Renamedphoto2.png image_2.png
Renamedphoto3.png image_3.png


2. Auto Summarize a CSV File

import pandas as pd
data=pd.DataFrame({
    'Name':['Alice','Bob','Charlie'],
    'Score':[90,85,95],
    'Age':[23,25,22]
})
display(data.describe())

Output:

Score
Age
count
3.0
3.000000
mean
90.0
23.333333
std
5.0
1.527525
min
85.0
22.000000
25%
87.5
22.500000
50%
90.0
23.000000
75%
92.5
24.000000
max
95.0
25.000000
3. Remove duplicate Entries

import pandas as pd
df=pd.DataFrame({
    'Name':['Alice','Bob','Alice','David'],
    'Score':[90,85,90,88]
})
df_clean=df.drop_duplicates()
display(df_clean)

Output:

Name
Score
0
Alice
90
1
Bob
85
3
David
88
4. Display Current time and date automatically

from datetime import datetime
now=datetime.now()
print("Current Date & Time:" , now.strftime("%Y-%m-%d %H:%M:%S"))

Output:
Current Date & Time: 2025-11-04 22:25:22

5. Convert text to pdf

from fpdf import FPDF

pdf=FPDF()
pdf.add_page()
pdf.set_font("Arial",size=12)
pdf.cell(200,10,txt="hello from python",ln=True,align='C')
pdf.output("note.pdf")
print("Pdf saved as note.pdf")

Output:
Pdf saved as note.pdf


6. Search for a word in multiple text files

import glob
keyword="Python"
for file in glob.glob("*.txt"):
    with open(file) as f:
        if keyword in f.read():
           print(f"'{keyword}' found in {file}")
    

Output:
'Python' found in daily_log.txt
'Python' found in destination_file.txt


7. Generate a random password

import string,random
chars=string.ascii_letters+string.digits+string.punctuation
password=''.join(random.sample(chars,10))
print("Generated password:",password)

Output:
Generated password: U:{t*k,JzK

Read More

Python Coding Challenge - Question with Answer (01091125)

Explanation:

1. List Initialization

nums = [5, 2, 8, 1]

A list named nums is created.

It contains four elements: 5, 2, 8, 1.

2. Initialize Result Variable

r = 0

A variable r is created to store the running total.

It is initially set to 0.

3. Start of the Loop

for i in range(len(nums)):

len(nums) = 4, so range(4) gives: 0, 1, 2, 3.

This loop runs once for each index in the list.

i represents the current index.

4. Update the Result

    r += nums[i] - i

For each index i:

Take the value at that index → nums[i]

Subtract the index → nums[i] - i

Add that result to r

5. Step-By-Step Calculation

i = 0

nums[0] = 5

5 − 0 = 5

r = 0 + 5 = 5

i = 1

nums[1] = 2

2 − 1 = 1

r = 5 + 1 = 6

i = 2

nums[2] = 8

8 − 2 = 6

r = 6 + 6 = 12

i = 3

nums[3] = 1

1 − 3 = −2

r = 12 − 2 = 10

6. Print Final Output

print(r)

Prints the final result.

Output:

10

 600 Days Python Coding Challenges with Explanation

Read More

Python Coding challenge - Day 835| What is the output of the following Python Code?

 

Code Explanation:

Importing the math module

import math

This imports Python’s built-in math module.

We need it because math.pi gives the value of π (3.14159…).

Defining the Circle class

class Circle:

This starts the definition of a class named Circle.

A class is a blueprint for creating objects.

Initializer method (constructor)

    def __init__(self, r):

        self.r = r

Explanation:

__init__ is called automatically when an object is created.

It receives r (radius).

self.r = r stores the radius in the object’s attribute r.

So, when we do Circle(5),

the object stores r = 5 inside itself.

Creating a readable property: area

    @property

    def area(self):

        return math.pi * self.r**2

Explanation:

@property decorator

Turns the method area() into a property, meaning you can access it like a variable, not a function.

area calculation

Formula used:

Area = π × r²

So:

Area = math.pi * (5)^2

     = 3.14159 * 25

     = 78.5398...

Printing the area (converted to integer)

print(int(Circle(5).area))

Breakdown:

Circle(5) → Creates a Circle with radius = 5.

.area → Gets the computed area property (≈ 78.5398).

int(...) → Converts it to an integer → 78.

print(...) → Prints 78.

Final Output

78

600 Days Python Coding Challenges with Explanation

Read More

Python Coding challenge - Day 836| What is the output of the following Python Code?

 

Code Explanation:

Importing the dataclass decorator

from dataclasses import dataclass

This imports @dataclass, a decorator that automatically adds useful methods to a class (like __init__, __repr__, etc.).

It helps create classes that mainly store data with less code.

Declaring the Product class as a dataclass

@dataclass

class Product:

@dataclass tells Python to automatically create:

an initializer (__init__)

readable string format

comparison methods

The class name is Product, representing an item with price and quantity.

Defining class fields

    price: int

    qty: int

These define the two attributes the class will store:

price → an integer value

qty → an integer quantity

With @dataclass, Python will automatically create:

def __init__(self, price, qty):

    self.price = price

    self.qty = qty

Creating a method to compute total cost

    def total(self):

        return self.price * self.qty

Explanation:

Defines a method named total.

It multiplies the product’s price by qty.

Example: price = 7, qty = 6 → total = 42.

Creating a Product object and printing result

print(Product(7, 6).total())

Breakdown:

Product(7, 6) → Creates a Product object with:

price = 7

qty = 6

.total() → Calls the method to compute 7 × 6 = 42.

print(...) → Displays 42.

Final Output

42

700 Days Python Coding Challenges with Explanation

Read More