Python-Programming-Code/docs/8_OOPs_in_Python.html at main · shikharkumar13/Python-Programming-Code

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<!doctype html>

<head>

<title>Object-Oriented Programming in Python: A Complete Guide · Python Programming Series</title>

<style>

:root{

--paper:#F7F4FF;--surface:#FFFFFF;--tint:#F1EBFF;

--ink:#1D1442;--ink-soft:#4A3F73;--ink-faint:#8A80AD;

--violet:#6B3CF5;--violet-deep:#4F22D9;--violet-soft:#ECE5FF;

--pink:#F0378A;--pink-text:#C41E6A;--pink-soft:#FFE8F2;

--mint:#00B894;--mint-text:#007F66;--mint-soft:#DDF7F0;

--sun:#FFB627;--sun-soft:#FFF3D6;

--orange:#FF6B35;--orange-text:#C2410C;--orange-soft:#FFE9DF;

--sky:#1E9BF0;--sky-text:#0B6FB8;--sky-soft:#E1F1FD;

--line:#E2DAF7;--line-strong:#C9BDF0;

--code-bg:#1F1147;--code-head:#180D3A;--code-line:#2E1D63;--out-bg:#170B36;

--r-s:8px;--r-m:14px;--r-l:22px;

--font-d:'Bricolage Grotesque','Arial Rounded MT Bold',sans-serif;

--font-b:'Figtree',-apple-system,'Segoe UI',sans-serif;

--font-m:'JetBrains Mono','SFMono-Regular',Consolas,monospace;

}

*,*::before,*::after{box-sizing:border-box;}

html{scroll-behavior:smooth;}

body{margin:0;background:var(--paper);color:var(--ink);font-family:var(--font-b);font-size:17px;line-height:1.68;-webkit-font-smoothing:antialiased;}

a{color:var(--violet-deep);text-decoration-color:rgba(107,60,245,.35);text-underline-offset:3px;text-decoration-thickness:2px;}

a:hover{text-decoration-color:currentColor;}

::selection{background:var(--pink);color:#fff;}

:focus-visible{outline:3px solid var(--pink);outline-offset:2px;border-radius:4px;}

.icon{width:1em;height:1em;display:inline-block;vertical-align:-.15em;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round;}

.shell{max-width:1300px;margin:0 auto;padding:0 clamp(16px,4vw,44px);}

.topbar{display:none;position:sticky;top:0;z-index:40;align-items:center;justify-content:space-between;padding:12px clamp(16px,4vw,44px);background:rgba(255,255,255,.94);backdrop-filter:blur(8px);border-bottom:2px solid var(--violet-soft);}

.topbar .brand{font-family:var(--font-d);font-weight:800;font-size:.98rem;color:var(--ink);}

.topbar .brand span{color:var(--violet);}

.topbar button{border:2px solid var(--violet-soft);background:var(--surface);border-radius:var(--r-s);width:40px;height:36px;display:flex;align-items:center;justify-content:center;cursor:pointer;color:var(--violet);}

/* ---------- Hero: the one loud moment ---------- */

.hero{position:relative;margin:clamp(16px,2.5vw,28px) 0 clamp(36px,5vw,56px);padding:clamp(36px,5.5vw,68px) clamp(22px,4.5vw,60px);background:var(--violet);color:#fff;border-radius:var(--r-l);overflow:hidden;display:grid;grid-template-columns:minmax(0,1.3fr) minmax(0,1fr);gap:clamp(28px,4vw,56px);align-items:center;}

.hero::before{content:"";position:absolute;width:420px;height:420px;border-radius:50%;background:var(--violet-deep);right:-120px;top:-160px;}

.hero::after{content:"";position:absolute;width:180px;height:180px;border-radius:50%;background:var(--pink);left:-70px;bottom:-90px;opacity:.9;}

.hero-copy,.hero-art{position:relative;z-index:1;}

.hero-eyebrow{display:flex;align-items:center;gap:12px;flex-wrap:wrap;font-weight:600;font-size:.95rem;color:rgba(255,255,255,.86);margin-bottom:20px;}

.hero-eyebrow .badge{background:var(--sun);color:var(--ink);font-family:var(--font-d);font-weight:800;padding:4px 13px;border-radius:999px;font-size:.92rem;}

h1.title{font-family:var(--font-d);font-weight:800;font-size:clamp(2.15rem,4.6vw,3.7rem);line-height:1.02;letter-spacing:-.025em;margin:0 0 20px;max-width:16ch;color:#fff;}

.hero-sub{font-size:clamp(1rem,1.5vw,1.12rem);color:rgba(255,255,255,.9);max-width:58ch;margin:0 0 28px;}

.hero-sub strong{color:#fff;font-weight:700;}

.hero-chips{display:flex;flex-wrap:wrap;gap:10px;}

.chip{display:flex;align-items:center;gap:8px;background:rgba(255,255,255,.13);border:1.5px solid rgba(255,255,255,.28);padding:7px 14px 7px 10px;border-radius:999px;font-size:.88rem;font-weight:600;color:#fff;}

.chip .icon{width:1.15em;height:1.15em;}

.chip:nth-child(1) .icon{color:var(--sun);}

.chip:nth-child(2) .icon{color:#7FF0D2;}

.chip:nth-child(3) .icon{color:#FF9BC6;}

.chip:nth-child(4) .icon{color:#9FD6FF;}

.hero-art{display:flex;flex-direction:column;align-items:center;}

.blueprint{width:min(250px,100%);border:2.5px dashed rgba(255,255,255,.75);border-radius:var(--r-m);padding:14px 16px 12px;font-family:var(--font-m);font-size:.8rem;color:#fff;background:rgba(255,255,255,.06);}

.bp-title{font-weight:700;margin-bottom:8px;}

.bp-title .kw{color:#FF9BC6;}

.bp-title .cn{color:var(--sun);}

.bp-line{padding:2px 0 2px 14px;color:rgba(255,255,255,.82);}

.bp-line.m{color:#7FF0D2;}

.fan{width:min(330px,100%);height:44px;display:block;}

.fan path{stroke:rgba(255,255,255,.7);stroke-width:2;fill:none;stroke-dasharray:4 4;vector-effect:non-scaling-stroke;}

.objs{display:grid;grid-template-columns:repeat(3,1fr);gap:10px;width:min(360px,100%);}

.obj{border-radius:12px;padding:10px 10px 9px;font-family:var(--font-m);font-size:.72rem;line-height:1.5;color:var(--ink);box-shadow:0 6px 0 rgba(29,20,66,.28);animation:stamp .5s cubic-bezier(.3,1.5,.6,1) both;}

.obj b{display:block;font-family:var(--font-d);font-size:1rem;font-weight:800;margin-bottom:3px;}

.obj span{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}

.o1{background:var(--sun);transform:rotate(-4deg);animation-delay:.25s;}

.o2{background:#7FF0D2;transform:rotate(2deg);animation-delay:.45s;}

.o3{background:#FF9BC6;transform:rotate(-1.5deg);animation-delay:.65s;}

@keyframes stamp{from{opacity:0;translate:0 -26px;scale:.85;}to{opacity:1;translate:0 0;scale:1;}}

.art-cap{margin:18px 0 0;font-family:var(--font-d);font-weight:700;font-size:.95rem;color:rgba(255,255,255,.9);}

/* ---------- Layout + sidebar ---------- */

.layout{display:grid;grid-template-columns:265px minmax(0,1fr);gap:clamp(24px,4vw,56px);align-items:start;padding-bottom:90px;}

.sidebar{position:sticky;top:24px;max-height:calc(100vh - 48px);overflow-y:auto;padding:16px 10px 16px 0;}

.sidebar::-webkit-scrollbar{width:5px;}

.sidebar::-webkit-scrollbar-thumb{background:var(--line-strong);border-radius:3px;}

.toc-label{font-family:var(--font-d);font-weight:800;font-size:1rem;color:var(--ink);margin:0 0 10px;padding-left:12px;}

.toc{list-style:none;margin:0;padding:0;}

.toc li{margin:0 0 2px;}

.toc a{display:flex;align-items:center;gap:10px;padding:7px 12px;font-size:.88rem;font-weight:500;color:var(--ink-soft);text-decoration:none;border-radius:10px;transition:background .15s,color .15s;}

.toc a .icon{width:1.05em;height:1.05em;flex:none;color:var(--violet);}

.toc a:hover{background:var(--violet-soft);color:var(--ink);}

.toc a.active{background:var(--violet);color:#fff;font-weight:600;}

.toc a.active .icon{color:var(--sun);}

/* ---------- Article ---------- */

.article{min-width:0;padding-top:8px;max-width:820px;}

.article h2{--acc:var(--violet);font-family:var(--font-d);font-weight:800;font-size:clamp(1.55rem,2.6vw,2rem);line-height:1.15;letter-spacing:-.015em;margin:64px 0 18px;scroll-margin-top:24px;display:flex;align-items:center;gap:14px;}

.article h2:nth-of-type(5n+2){--acc:var(--pink);}

.article h2:nth-of-type(5n+3){--acc:var(--mint);}

.article h2:nth-of-type(5n+4){--acc:var(--orange);}

.article h2:nth-of-type(5n+5){--acc:var(--sky);}

.article>h2:first-of-type{margin-top:4px;}

.article>hr:first-child{display:none;}

.article h2 .h-icon{width:2.6rem;height:2.6rem;flex:none;display:grid;place-items:center;background:var(--acc);color:#fff;border-radius:12px;transform:rotate(-4deg);box-shadow:0 4px 0 rgba(29,20,66,.18);}

.article h2 .h-icon .icon{width:1.35rem;height:1.35rem;stroke-width:2;}

.article h3{font-family:var(--font-d);font-weight:700;font-size:1.2rem;margin:34px 0 10px;scroll-margin-top:24px;color:var(--ink);}

.article p{margin:0 0 17px;}

.article ul,.article ol{margin:0 0 20px;padding-left:1.35em;}

.article li{margin-bottom:8px;padding-left:.2em;}

.article ul li::marker{color:var(--pink);font-size:1.15em;}

.article ol li::marker{color:var(--violet);font-family:var(--font-d);font-weight:800;}

.article strong{font-weight:700;}

.article hr{border:0;height:6px;width:110px;margin:52px auto;border-radius:6px;background:linear-gradient(90deg,var(--violet) 0 20%,var(--pink) 20% 40%,var(--mint) 40% 60%,var(--sun) 60% 80%,var(--sky) 80% 100%);}

.article code{font-family:var(--font-m);font-size:.84em;background:var(--pink-soft);padding:.12em .4em;border-radius:6px;color:var(--pink-text);}

.article blockquote{margin:22px 0;padding:16px 20px;border-left:5px solid var(--sun);background:var(--sun-soft);border-radius:0 var(--r-m) var(--r-m) 0;color:var(--ink);}

.article blockquote p{margin:0;color:inherit;}

.table-wrap{overflow-x:auto;margin:22px 0 28px;border-radius:var(--r-m);border:2px solid var(--violet-soft);background:var(--surface);}

.article table{width:100%;border-collapse:collapse;font-size:.9rem;}

.article thead th{background:var(--violet);color:#fff;font-family:var(--font-d);font-weight:700;text-align:left;padding:12px 16px;white-space:nowrap;font-size:.9rem;}

.article tbody td{padding:11px 16px;border-bottom:1px solid var(--line);vertical-align:top;}

.article tbody tr:last-child td{border-bottom:none;}

.article tbody tr:nth-child(even){background:#FAF7FF;}

.article tbody td code{white-space:nowrap;}

/* ---------- Code ---------- */

.code-card{margin:22px 0 26px;border-radius:var(--r-m);overflow:hidden;background:var(--code-bg);box-shadow:0 6px 0 var(--violet-soft);}

.code-card .code-head{display:flex;align-items:center;justify-content:space-between;padding:9px 14px;background:var(--code-head);border-bottom:1px solid var(--code-line);}

.code-card .dots{display:flex;gap:6px;}

.code-card .dots span{width:10px;height:10px;border-radius:50%;display:block;}

.code-card .dots span:nth-child(1){background:var(--pink);}

.code-card .dots span:nth-child(2){background:var(--sun);}

.code-card .dots span:nth-child(3){background:var(--mint);}

.code-card .lang{font-family:var(--font-m);font-size:.72rem;color:#9C8CD6;}

.code-card .copy-btn{font-family:var(--font-b);font-weight:600;font-size:.76rem;color:#E4DCFF;background:rgba(255,255,255,.06);border:1px solid #3D2A7A;border-radius:7px;padding:4px 10px;cursor:pointer;display:flex;align-items:center;gap:6px;transition:background .15s,border-color .15s;}

.code-card .copy-btn:hover{background:var(--violet);border-color:var(--violet);color:#fff;}

.code-card .copy-btn .icon{width:.95em;height:.95em;}

.code-card pre{margin:0;padding:16px 20px;overflow-x:auto;font-size:.85rem;line-height:1.6;}

.code-card code{font-family:var(--font-m);font-size:1em;line-height:inherit;color:#F3EEFF;background:none;padding:0;border-radius:0;}

.code-card .k,.code-card .kn,.code-card .kd,.code-card .kc,.code-card .ow{color:#FF6FAE;}

.code-card .nb,.code-card .bp{color:#9FD6FF;}

.code-card .nf,.code-card .fm{color:#4BE3C1;}

.code-card .s,.code-card .s1,.code-card .s2,.code-card .sa,.code-card .sd,.code-card .se{color:#FFD166;}

.code-card .si{color:#FF9F5A;}

.code-card .mi,.code-card .mf{color:#FF9F5A;}

.code-card .o,.code-card .p{color:#B7A8E8;}

.code-card .c,.code-card .c1,.code-card .cm{color:#8E7CC3;font-style:italic;}

.code-card .n{color:#F3EEFF;}

.code-card .nc,.code-card .ne{color:#7CC8FF;font-weight:600;}

.output-card{margin:-26px 0 26px;border-radius:0 0 var(--r-m) var(--r-m);overflow:hidden;background:var(--out-bg);border-top:2px dashed #3D2A7A;box-shadow:0 6px 0 var(--violet-soft);position:relative;z-index:1;}

.output-card::before{content:"Output";display:block;font-family:var(--font-b);font-weight:700;font-size:.74rem;color:#4BE3C1;padding:9px 20px 0;}

.output-card pre{margin:0;padding:4px 20px 16px;overflow-x:auto;font-size:.82rem;line-height:1.6;}

.output-card code{font-family:var(--font-m);font-size:1em;line-height:inherit;color:#D7CCFF;background:none;padding:0;border-radius:0;}

.diagram-card{margin:22px 0 26px;border-radius:var(--r-m);overflow:hidden;position:relative;border:2.5px dashed var(--line-strong);background:var(--surface);}

.diagram-card::before{content:"diagram";position:absolute;top:10px;right:14px;font-family:var(--font-b);font-weight:700;font-size:.74rem;color:var(--violet);}

.diagram-card pre{margin:0;padding:26px 22px 20px;overflow-x:auto;}

.diagram-card code{font-family:var(--font-m);font-size:.95rem;line-height:1.5;color:var(--violet-deep);font-weight:700;background:none;padding:0;white-space:pre;}

.svg-diagram{margin:24px 0 28px;padding:22px 20px 18px;background:var(--surface);border:2px solid var(--violet-soft);border-radius:var(--r-m);}

.svg-diagram{overflow-x:auto;}

.svg-diagram svg{width:100%;min-width:560px;height:auto;display:block;}

.svg-diagram .cap{font-size:.86rem;font-weight:500;color:var(--ink-faint);text-align:center;margin-top:12px;}

.article-end{margin-top:56px;padding:30px 30px;border-radius:var(--r-l);background:var(--violet);color:#fff;position:relative;overflow:hidden;}

.article-end::after{content:"";position:absolute;width:140px;height:140px;border-radius:50%;background:var(--sun);right:-50px;bottom:-60px;}

.article-end p{margin:0;font-size:1.06rem;color:rgba(255,255,255,.92);position:relative;z-index:1;max-width:62ch;}

.article-end p strong{color:#fff;}

footer.site-footer{border-top:2px solid var(--violet-soft);margin-top:30px;padding:22px clamp(16px,4vw,44px) 40px;display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:10px;}

footer.site-footer .f-left{font-size:.88rem;font-weight:500;color:var(--ink-faint);}

footer.site-footer a{font-size:.9rem;font-weight:600;}

@media(max-width:960px){

.topbar{display:flex;}

.layout{grid-template-columns:1fr;}

.article{max-width:none;}

.sidebar{position:fixed;inset:60px 0 0 0;z-index:35;background:var(--paper);padding:18px clamp(16px,4vw,44px) 24px;transform:translateX(-100%);transition:transform .2s;max-height:none;height:calc(100vh - 60px);}

.sidebar.open{transform:translateX(0);}

.hero{grid-template-columns:1fr;}

}

@media(max-width:520px){

.article h2 .h-icon{width:2.2rem;height:2.2rem;}

.obj{font-size:.66rem;padding:9px 8px;}

}

@media(prefers-reduced-motion:reduce){html{scroll-behavior:auto;}.sidebar{transition:none;}.obj{animation:none;}}

</style>

</head>

<body>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</symbol>

</defs></svg>

§9  OOP in Python

</button>

</div>

<div class="hero-eyebrow">Article 9 Python Programming Series</div>

<h1 class="title">Object-Oriented Programming in Python: A Complete Guide</h1>

Before OOP, code is usually written procedurally: one long list of instructions, with data passed from function to function. That works fine for small scripts, but it gets hard to manage as a program grows. Object-Oriented Programming groups related data and the functions that act on it into a single unit called an object, which makes code easier to read, reuse, and extend.

<div class="chip"><svg class="icon"><use href="#icon-blueprint"></use></svg> Classes & objects</div>

<div class="chip"><svg class="icon"><use href="#icon-tree"></use></svg> All 5 types of inheritance</div>

<div class="chip"><svg class="icon"><use href="#icon-morph"></use></svg> Polymorphism & duck typing</div>

<div class="chip"><svg class="icon"><use href="#icon-lock"></use></svg> Encapsulation & abstraction</div>

</div>

<div class="bp-title">class Account:</div>

<div class="bp-line m">deposit()</div>

</div>

<div class="obj o1">acc1Rishabh10125000</div>

<div class="obj o2">acc2Priya10267548</div>

<div class="obj o3">acc3Roshan10376000</div>

</div>

One class, three objects

</div>

</section>

<li><a href="#procedural-vs-oop-side-by-side"><svg class="icon"><use href="#icon-layers"></use></svg>Procedural vs. OOP, Side by Side</a></li>

<li><a href="#the-four-pillars-of-oop"><svg class="icon"><use href="#icon-layers"></use></svg>The Four Pillars of OOP</a></li>

<li><a href="#1-classes-and-objects"><svg class="icon"><use href="#icon-blueprint"></use></svg>1. Classes and Objects</a></li>

<li><a href="#2-class-variables-vs-instance-variables"><svg class="icon"><use href="#icon-database"></use></svg>2. Class Variables vs. Instance Variables</a></li>

<li><a href="#3-methods-functions-inside-a-class"><svg class="icon"><use href="#icon-function"></use></svg>3. Methods: Functions Inside a Class</a></li>

<li><a href="#4-encapsulation"><svg class="icon"><use href="#icon-lock"></use></svg>4. Encapsulation</a></li>

<li><a href="#5-inheritance"><svg class="icon"><use href="#icon-tree"></use></svg>5. Inheritance</a></li>

<li><a href="#6-polymorphism"><svg class="icon"><use href="#icon-morph"></use></svg>6. Polymorphism</a></li>

<li><a href="#7-overriding-overloading-and-operator-overloading"><svg class="icon"><use href="#icon-overload"></use></svg>7. Overriding, Overloading, and Operator Overloading</a></li>

<li><a href="#8-abstraction"><svg class="icon"><use href="#icon-abstract"></use></svg>8. Abstraction</a></li>

<li><a href="#summary"><svg class="icon"><use href="#icon-table"></use></svg>Summary</a></li>

</ul>

</nav>

<hr />

<h2 id="procedural-vs-oop-side-by-side"><svg class="icon"><use href="#icon-layers"></use></svg>Procedural vs. OOP, Side by Side</h2>

def deposit_money(account_name, balance, amount):

balance += amount

return balance

# OOP way: the action belongs to the object

account.deposit(500)

</code></pre></div>

<thead>

<tr>

<th>Aspect</th>

<th>Procedural</th>

<th>Object-Oriented</th>

</tr>

</thead>

<tbody>

<tr>

<td>Focus</td>

<td>Functions</td>

<td>Objects and their interactions</td>

</tr>

<tr>

<td>Passed freely between functions</td>

<td>Bundled inside the object</td>

</tr>

<tr>

<td>Code reuse</td>

<td>Functions</td>

<td>Inheritance</td>

</tr>

<tr>

<td>Modeling the real world</td>

<td>Awkward</td>

<td>Natural</td>

</tr>

</tbody>

</table></div>

In the OOP version, the account knows how to deposit into itself. The data (the balance) and the behavior (the deposit action) live in the same place, which is the core idea behind everything else in this guide.

<h2 id="the-four-pillars-of-oop"><svg class="icon"><use href="#icon-layers"></use></svg>The Four Pillars of OOP</h2>

<ol>

<li>Encapsulation: bundle data and methods together, and control who can access the data.</li>

<li>Inheritance: build new classes by extending existing ones.</li>

<li>Polymorphism: the same method name behaves differently depending on the object.</li>

<li>Abstraction: expose only what's necessary, hide the complexity.</li>

</ol>

<text x="79" y="34" text-anchor="middle" font-size="11" font-weight="700" fill="#4F22D9">ENCAPSULATION</text>

<text x="79" y="70" text-anchor="middle" font-size="9.5" fill="#4A3F73">Bundle data +</text>

<text x="79" y="84" text-anchor="middle" font-size="9.5" fill="#4A3F73">control access</text>

<text x="79" y="120" text-anchor="middle" font-size="8.5" fill="#8A80AD">Only the teller</text>

<text x="79" y="132" text-anchor="middle" font-size="8.5" fill="#8A80AD">opens the vault</text>

<text x="239" y="34" text-anchor="middle" font-size="11" font-weight="700" fill="#007F66">INHERITANCE</text>

<text x="239" y="70" text-anchor="middle" font-size="9.5" fill="#4A3F73">Reuse + extend</text>

<text x="239" y="84" text-anchor="middle" font-size="9.5" fill="#4A3F73">existing classes</text>

<text x="239" y="120" text-anchor="middle" font-size="8.5" fill="#8A80AD">SavingsAccount</text>

<text x="239" y="132" text-anchor="middle" font-size="8.5" fill="#8A80AD">is also an Account</text>

<text x="399" y="34" text-anchor="middle" font-size="11" font-weight="700" fill="#C2410C">POLYMORPHISM</text>

<text x="399" y="84" text-anchor="middle" font-size="9.5" fill="#4A3F73">different behavior</text>

<text x="399" y="120" text-anchor="middle" font-size="8.5" fill="#8A80AD">.speak() → Meow,</text>

<text x="399" y="132" text-anchor="middle" font-size="8.5" fill="#8A80AD">Woof, or Quack</text>

<text x="559" y="34" text-anchor="middle" font-size="11" font-weight="700" fill="#C41E6A">ABSTRACTION</text>

<text x="559" y="70" text-anchor="middle" font-size="9.5" fill="#4A3F73">Define WHAT,</text>

<text x="559" y="120" text-anchor="middle" font-size="8.5" fill="#8A80AD">Brake pedal hides</text>

<text x="559" y="132" text-anchor="middle" font-size="8.5" fill="#8A80AD">the hydraulics</text>

</svg>

<div class="cap">The four pillars, at a glance</div></div>Big tech runs on exactly these ideas: every Google search, Gmail message, and YouTube video is an object with its own attributes and methods. Every Amazon product, order, and shipment is an object interacting with others. An Uber <code>Ride</code> object ties together a <code>Driver</code>, a <code>Rider</code>, a <code>Car</code>, and a <code>Route</code>. Netflix uses one base class to power <code>Movie</code>, <code>Series</code>, and <code>Documentary</code> objects that all stream the same way.

We'll use a banking application as the running example throughout.

<hr />

<h2 id="1-classes-and-objects"><svg class="icon"><use href="#icon-blueprint"></use></svg>1. Classes and Objects</h2>

A class is a blueprint that defines what an entity looks like and what it can do. An object is a specific instance built from that blueprint.

Analogy: the blueprint of a house is the class. It describes the rooms, doors, and windows, but you can't live in a blueprint. Your actual house, built from that blueprint with its own address and paint color, is the object. From one blueprint you can build many houses; from one class you can create many objects.

A few things worth internalizing:

<ul>

<li>A class defines both the structure (what data it holds) and the behavior (what it can do).</li>

<li>Each object gets its own copy of the data, with its own values.</li>

<li>All objects of the same class share the same methods.</li>

<li>Defining a class doesn't create any objects; each object's own data only comes into existence when you create that object.</li>

</ul>

<h3 id="__init__-the-constructor"><code>__init__</code>: The Constructor</h3>

<code>__init__</code> is a special method Python calls automatically the moment you create an object. It sets up the object's starting data.

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>acc1 = Account('Rishabh', 101, 25000)

# Python automatically calls Account.__init__(acc1, 'Rishabh', 101, 25000)

</code></pre></div>

<h3 id="self-the-object-referring-to-itself"><code>self</code>: The Object Referring to Itself</h3>

<code>self</code> is how a method (a function defined inside a class) refers to the specific object it's being called on. When you write <code>acc1.deposit(500)</code>, Python translates that internally to <code>Account.deposit(acc1, 500)</code>, passing the object itself as the first argument automatically. That's why every regular method inside a class lists <code>self</code> as its first parameter. Think of <code>self</code> as the word "I" in a sentence: it's how the object refers to its own data.

self.name = name # attribute: belongs to THIS object

self.acc_no = accountnumber

self.bal = balance

</code></pre></div>

acc1 = Account('Rishabh', 101, 25000)

acc2 = Account('Priya', 102, 67548)

acc3 = Account('Roshan', 103, 76000)

print(acc1.bal, acc1.name, acc1.acc_no)

print(acc2.bal, acc2.name, acc2.acc_no)

print(acc3.bal, acc3.name, acc3.acc_no)

</code></pre></div>

<div class="output-card"><pre><code>25000 Rishabh 101

67548 Priya 102

76000 Roshan 103

</code></pre></div>

<h3 id="a-class-can-model-anything">A Class Can Model Anything</h3>

A class isn't limited to bank accounts. Here's a <code>Student</code> class, which reinforces that a class is just a blueprint for whatever entity you need:

self.name = name

self.roll_no = roll_number

self.marks = marks

def is_passing(self):

return self.marks >= 50

def get_grade(self):

if self.marks >= 90:

return 'A+'

elif self.marks >= 75:

return 'A'

elif self.marks >= 60:

return 'B'

elif self.marks >= 50:

return 'C'

else:

return 'F'

</code></pre></div>

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>s1 = Student('Alice', 1, 92)

s2 = Student('Bob', 2, 47)

s3 = Student('Carol', 3, 68)

print(s1.name, '| Grade:', s1.get_grade(), '| Passing:', s1.is_passing())

print(s2.name, '| Grade:', s2.get_grade(), '| Passing:', s2.is_passing())

print(s3.name, '| Grade:', s3.get_grade(), '| Passing:', s3.is_passing())

</code></pre></div>

<div class="output-card"><pre><code>Alice | Grade: A+ | Passing: True

Bob | Grade: F | Passing: False

Carol | Grade: B | Passing: True

</code></pre></div>

<h3 id="__str__-controlling-what-print-shows"><code>__str__</code>: Controlling What <code>print()</code> Shows</h3>

Printing an object without any special setup shows something unhelpful, like <code><__main__.Account object at 0x0000013183...></code>. <code>__str__</code> is a dunder method (named for its double underscores) that controls what appears when you use <code>print()</code> or <code>str()</code> on an object. Python calls it automatically; you don't need to call <code>obj.__str__()</code> yourself.

self.name = name

self.acc_no = accountnumber

self.bal = balance

def __str__(self):

return f'Account #{self.acc_no} belongs to {self.name} | Balance: ${self.bal}'

</code></pre></div>

Think of <code>__str__</code> as the label on a product: without it, all a stranger sees is a box; with it, they see what's actually inside.

<h3 id="amazons-product-class">Amazon's Product Class</h3>

Amazon has over 350 million products, and every one is an object. The <code>Product</code> class defines the shared structure (an ASIN, Amazon's unique product ID, title, price, rating), while each object holds the unique data for one specific product.

def __init__(self, asin, title, price, seller, rating=0.0, review_count=0):

self.asin = asin

self.title = title

self.price = price

self.seller = seller

self.rating = rating

self.review_count = review_count

def __str__(self):

return f'[{self.asin}] {self.title} | ${self.price} | {self.rating:.1f}/5 ({self.review_count} reviews)'

def apply_discount(self, percent):

self.price = round(self.price * (1 - percent / 100), 2)

def add_review(self, new_rating):

total_combined_rating = self.rating * self.review_count + new_rating

self.review_count += 1

self.rating = total_combined_rating / self.review_count

</code></pre></div>

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>laptop = Product('B09G9HDGY2', 'Apple MacBook Pro 14-inch', 1999.99, 'Apple Inc.', 4.8, 2341)

headphones = Product('B07Q9MJKBV', 'Sony WH-1000XM4 Headphones', 279.99, 'Sony', 4.7, 18923)

laptop.apply_discount(15) # Prime Day 15% off

headphones.add_review(5) # a new 5-star review comes in

print(laptop)

print(headphones)

</code></pre></div>

<div class="output-card"><pre><code>[B09G9HDGY2] Apple MacBook Pro 14-inch | $1699.99 | 4.8/5 (2341 reviews)

[B07Q9MJKBV] Sony WH-1000XM4 Headphones | $279.99 | 4.7/5 (18924 reviews)

</code></pre></div>

<code>add_review</code> is worth walking through, because the trick behind it comes up constantly in real systems. Re-reading every rating a product has ever received each time a new one arrives would be far too slow for a product with thousands of reviews, so this method keeps just two running numbers per product: the current average rating and the total review count. When a new review comes in, the method reverse-engineers the historical total from what it already has: <code>total = average × count</code>. For the headphones, that's <code>4.7 × 18923 = 88938.1</code>. Add the new 5-star rating to get <code>88943.1</code>, bump the count to <code>18924</code>, and divide to get the fresh average. Three lines, and the full rating history was never needed.

One detail matters here: the method stores the full-precision average and only rounds it for display, inside <code>__str__</code> (the <code>:.1f</code>). If it stored the rounded <code>4.7</code> back, every later calculation would start from a slightly wrong total, and on a product with thousands of reviews the rounded average could never move at all. Even a thousand new 1-star reviews would leave it stuck at 4.7.

<hr />

<h2 id="2-class-variables-vs-instance-variables"><svg class="icon"><use href="#icon-database"></use></svg>2. Class Variables vs. Instance Variables</h2>

There are two kinds of data in a class, and the difference matters:

<thead>

<tr>

<th>Defined where</th>

<th>Shared?</th>

<th>Example</th>

</tr>

</thead>

<tbody>

<tr>

<td>Instance variable</td>

<td>Inside <code>__init__</code> with <code>self.</code></td>

<td>No, unique per object</td>

<td>customer name, balance</td>

</tr>

<tr>

<td>Class variable</td>

<td>At class level, outside <code>__init__</code></td>

<td>Yes, same for every object</td>

<td>bank name, IFSC code, counter</td>

</tr>

</tbody>

</table></div>

Analogy: a class variable is a shared whiteboard in an office; every object reads the exact same thing off it. An instance variable is each person's private notebook; every object's copy is independent. Change the whiteboard, and everyone sees the change instantly. Scribble in your own notebook, and nobody else's changes.

counter = 1 # class variable: shared by every Account

bank_name = 'PyBank' # class variable: same for all accounts

ifsc_code = 'PYBN0001234' # class variable: same branch for all

self.name = name # instance variable

self.acc_no = Account.counter # read the shared counter

Account.counter += 1 # then bump it for the next account

self.bal = balance # instance variable

def __str__(self):

return f'[{Account.bank_name}] Account #{self.acc_no} | {self.name} | ${self.bal}'

</code></pre></div>

print('Total accounts created so far:', Account.counter - 1)

print('Bank IFSC Code:', Account.ifsc_code)

</code></pre></div>

<div class="output-card"><pre><code>Total accounts created so far: 3

Bank IFSC Code: PYBN0001234

</code></pre></div>

The <code>counter</code> class variable is what lets the class hand out sequential account numbers automatically, a genuinely useful pattern worth remembering on its own.

<h3 id="ubers-ride-counter-and-surge-pricing">Uber's Ride Counter and Surge Pricing</h3>

Uber processes over 25 million rides a day, with data living at two different levels: <code>total_rides</code> and <code>surge_multiplier</code> are class variables (they apply globally), while the rider, driver, and fare of any specific ride are instance variables.

total_rides = 0 # class variable: tracks every ride ever created

surge_multiplier = 1.0 # class variable: changed globally during peak hours

def __init__(self, rider, driver, pickup, destination, base_fare):

self.rider = rider

self.driver = driver

self.pickup = pickup

self.destination = destination

self.base_fare = base_fare

Ride.total_rides += 1

self.ride_id = Ride.total_rides

def get_final_fare(self):

return round(self.base_fare * Ride.surge_multiplier, 2)

</code></pre></div>

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>ride1 = Ride('Alice', 'Carlos', 'Marina District', 'SFO Airport', 45.00)

ride2 = Ride('Bob', 'Priya', 'Downtown', 'Oakland', 22.50)

# Friday night: surge kicks in. This ONE change affects the fare of every ride, even ride1 and ride2

Ride.surge_multiplier = 2.3

ride3 = Ride('Carol', 'Sam', 'Tenderloin', 'Caltrain', 15.00)

print(f'Ride 3 fare with surge: ${ride3.get_final_fare()}')

print('Total rides so far:', Ride.total_rides)

</code></pre></div>

<div class="output-card"><pre><code>Ride 3 fare with surge: $34.5

Total rides so far: 3

</code></pre></div>

<hr />

<h2 id="3-methods-functions-inside-a-class"><svg class="icon"><use href="#icon-function"></use></svg>3. Methods: Functions Inside a Class</h2>

Methods are just functions defined inside a class. They always take <code>self</code> first so they can read and change the object's own data, which is what lets objects do things: deposit money, send a message, play a song.

self.name = name

self.acc_no = accountnumber

self.bal = balance

def deposit(self, amount):

if amount > 0:

self.bal += amount

print(f"Deposited ${amount} to {self.name}'s account. New balance: ${self.bal}")

else:

print('Deposit amount must be positive.')

def withdraw(self, amount):

if amount <= 0:

print('Withdraw amount must be positive.')

elif amount > self.bal:

print('Insufficient funds!')

else:

self.bal -= amount

print(f"Withdrew ${amount} from {self.name}'s account. New balance: ${self.bal}")

def transfer(self, amount, other_account):

if amount <= 0:

print('Transfer amount must be positive.')

elif amount > self.bal:

print('Insufficient funds to transfer!')

else:

self.withdraw(amount)

other_account.deposit(amount)

print('Transfer complete.')

</code></pre></div>

<code>transfer</code> calls <code>withdraw</code> on itself and <code>deposit</code> on the other account; objects interacting with other objects is exactly how the real world works, and exactly why bundling data with behavior pays off.

acc1.deposit(10000)

acc1.transfer(20000, acc2)

</code></pre></div>

<div class="output-card"><pre><code>Deposited $10000 to Rishabh's account. New balance: $35000

Withdrew $20000 from Rishabh's account. New balance: $15000

Deposited $20000 to Priya's account. New balance: $87548

Transfer complete.

</code></pre></div>

<hr />

<h2 id="4-encapsulation"><svg class="icon"><use href="#icon-lock"></use></svg>4. Encapsulation</h2>

Encapsulation means bundling data and methods together, and controlling who can actually access that data.

Without encapsulation, anyone can reach in and set invalid data directly:

self.name = name

self.balance = balance # public attribute; anyone can change it

acc = Account('Alice', 5000)

acc.balance = -99999999 # nothing stops this; it should never be allowed

</code></pre></div>

Encapsulation fixes this by making attributes private and forcing access through controlled methods.

<h3 id="access-levels-in-python">Access Levels in Python</h3>

<thead>

<tr>

<th>Convention</th>

<th>Syntax</th>

<th>Meaning</th>

</tr>

</thead>

<tbody>

<tr>

<td>Public</td>

<td>Accessible from anywhere (the default)</td>

</tr>

<tr>

<td>Protected</td>

<td>Single underscore: "please don't touch this" (a convention, not enforced)</td>

</tr>

<tr>

<td>Private</td>

<td>Double underscore: name-mangled, harder to reach from outside</td>

</tr>

</tbody>

</table></div>

Analogy: think of these three levels like rooms in your own house. Public is the front yard, anyone walking by can see it. Protected is the living room, meant for family and close friends, though a stranger who lets themselves in technically still could. Private is a locked diary in your room: nobody's supposed to read it, but a determined person who really wants to could still pick the lock. That last point matters more than it sounds: Python doesn't truly block access to private attributes. It uses name mangling, quietly renaming <code>self.__balance</code> to <code>self._Account__balance</code> internally. You can still reach it from outside, but only by deliberately going out of your way, which is exactly the point: the double underscore is a strong "keep out" sign, not an unbreakable lock.

<h3 id="getters-and-setters">Getters and Setters</h3>

Since private attributes aren't meant to be accessed directly from outside the class, controlled access comes through two kinds of methods: a getter reads and returns the private value, and a setter writes it, but only after validating what's being written.

self.name = name

self.__balance = balance # private

if amount > 0:

self.__balance += amount

def get_balance(self): # getter: safe read

return self.__balance

def set_balance(self, amount): # setter: write WITH validation

if isinstance(amount, (int, float)) and amount >= 0:

self.__balance = amount

print(f'Balance updated to ${self.__balance}')

else:

print('Invalid amount. Balance must be a non-negative number.')

</code></pre></div>

print(f'Current balance: ${account.get_balance()}')

account.set_balance('abc') # rejected: not a number

account.set_balance(-500) # rejected: negative

account.set_balance(9999) # accepted

</code></pre></div>

<div class="output-card"><pre><code>Current balance: $100

Invalid amount. Balance must be a non-negative number.

Balance updated to $9999

</code></pre></div>

The name-mangling behavior mentioned earlier is easy to see directly on this same object:

</code></pre></div>

<div class="output-card"><pre><code>AttributeError: 'Account' object has no attribute '__balance'

</code></pre></div>

<div class="output-card"><pre><code>9999

</code></pre></div>

The setter is the gatekeeper here. It's the same idea as a bank teller: you don't reach into the vault yourself, you ask the teller, and the teller checks the rules before touching anything.

<h3 id="apples-credit-card-encapsulated-financial-data">Apple's Credit Card: Encapsulated Financial Data</h3>

When you add a card to Apple Wallet, Apple never stores or displays your full card number; the real number stays private, and the app only ever shows the last four digits. Stripe follows the same pattern with tokenization, covered later in this guide.

self.holder_name = holder_name

self.__card_number = str(card_number) # private, never exposed in full

self.__cvv = cvv # private

self.__balance = 0

self.__credit_limit = credit_limit

def get_masked_number(self):

return f'**** **** **** {self.__card_number[-4:]}'

def get_available_credit(self):

return self.__credit_limit - self.__balance

def get_utilization(self):

return round((self.__balance / self.__credit_limit) * 100, 1)

def charge(self, amount, merchant):

if amount <= 0 or amount > self.get_available_credit():

print(f'Declined at {merchant}.')

return False

self.__balance += amount

print(f'Approved: ${amount} at {merchant} | Remaining credit: ${self.get_available_credit()}')

return True

def pay_bill(self, amount):

payment = min(amount, self.__balance) # can't ever overpay

self.__balance -= payment

print(f'Payment of ${payment} received. Remaining balance: ${self.__balance}')

def __str__(self):

return f'Card: {self.get_masked_number()} | {self.holder_name} | Utilization: {self.get_utilization()}%'

</code></pre></div>

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>card = CreditCard('John Doe', '4111111111111234', 123, 5000)

card.charge(1500, 'Amazon')

card.charge(2000, 'Apple Store')

print(card)

card.pay_bill(1000)

</code></pre></div>

<div class="output-card"><pre><code>Approved: $1500 at Amazon | Remaining credit: $3500

Approved: $2000 at Apple Store | Remaining credit: $1500

Declined at Best Buy.

Card: **** **** **** 1234 | John Doe | Utilization: 70.0%

Payment of $1000 received. Remaining balance: $2500

</code></pre></div>

Every getter here exposes a calculated value (a masked number, a percentage) without ever revealing the private data it was computed from.

<hr />

<h2 id="5-inheritance"><svg class="icon"><use href="#icon-tree"></use></svg>5. Inheritance</h2>

Inheritance lets a new class (the child or subclass) reuse and extend the code of an existing class (the parent or superclass). It models the "is-a" relationship: a <code>SavingsAccount</code> is an <code>Account</code>. Without inheritance, <code>deposit()</code> and <code>withdraw()</code> would need to be copy-pasted into every account type; with it, you write them once in the parent and every child gets them automatically.

<h3 id="super-calling-the-parents-method"><code>super()</code>: Calling the Parent's Method</h3>

When a child class defines its own <code>__init__</code>, it usually still needs the parent's <code>__init__</code> to run, so the parent's attributes get set up properly. <code>super()</code> does exactly that:

super().__init__(name, acc_no, balance) # run Account's setup first

self.gender = gender # then add the child's own data

</code></pre></div>

Think of <code>super()</code> as passing work up the chain: let the parent handle what it already knows how to do, then add whatever is specific to the child on top.

<h3 id="the-five-types-of-inheritance">The Five Types of Inheritance</h3>

<ol>

<li>Single: one child inherits from one parent.</li>

<li>Multiple: one child inherits from two or more parents.</li>

<li>Multilevel: a chain, grandparent → parent → child.</li>

<li>Hierarchical: multiple children inherit from the same parent.</li>

<li>Hybrid: a mix of the patterns above.</li>

</ol>

<h3 id="51-single-inheritance">5.1 Single Inheritance</h3>

One parent, one child, nothing more. <code>SavingsAccount</code> reuses everything <code>Account</code> already does, and adds a small transaction limit of its own on top:

self.name = name

self.acc_no = accountnumber

self.bal = balance

self.numtrans = 0 # transactions done today

self.maxtrans = 2 # max transactions allowed per day

if amount > 0 and self.numtrans < self.maxtrans:

self.bal += amount

self.numtrans += 1

print(f'Deposited ${amount}. Balance: ${self.bal}')

elif self.numtrans >= self.maxtrans:

print('Transaction limit reached for today.')

else:

print('Deposit amount must be positive.')

class SavingsAccount(Account):

pass # 'pass' means no extra code: it uses everything from Account, unchanged

</code></pre></div>

<div class="code-card"><div class="code-head"><div class="dots"></div>python<button class="copy-btn" type="button"><svg class="icon"><use href="#icon-copy"></use></svg>Copy</button></div><pre><code>sav1 = SavingsAccount('Vinay', 301, 90800)

sav1.deposit(5000) # transaction 1

sav1.deposit(5000) # transaction 2

sav1.deposit(5000) # refused: the daily limit is 2

</code></pre></div>

<div class="output-card"><pre><code>Deposited $5000. Balance: $95800

Deposited $5000. Balance: $100800

Transaction limit reached for today.

</code></pre></div>

<code>SavingsAccount</code> gets <code>deposit()</code>, the transaction counter, everything, entirely for free. The moment a second class also starts inheriting from the same parent (section 5.4 shows three classes sharing <code>BankAccount</code>), the pattern has become hierarchical rather than single, since single inheritance describes one parent feeding exactly one child.

<h3 id="52-multiple-inheritance">5.2 Multiple Inheritance</h3>

A child can inherit from several parents at once. A Tesla is a <code>Vehicle</code>, an <code>ElectricVehicle</code>, and uses <code>GPSNavigator</code>, all at the same time:

self.make = make

self.model = model

def start(self):

return f'{self.make} {self.model} is starting...'

class ElectricVehicle:

self.battery = battery_kwh

self.charge_level = 100

def get_range(self):

miles = int(self.battery * (self.charge_level / 100) * 2.5)

return f'{miles} miles'

class GPSNavigator:

def get_location(self):

return '37.7749 N, 122.4194 W'

def navigate(self, destination):

return f'Routing to {destination} from {self.get_location()}'

class TeslaModel3(Vehicle, ElectricVehicle, GPSNavigator):

Vehicle.__init__(self, 'Tesla', model)

ElectricVehicle.__init__(self, battery_kwh=75)

self.autopilot = autopilot

def self_drive(self, destination):

if self.autopilot:

return f'Autopilot engaged. {self.navigate(destination)} | Range: {self.get_range()}'

return 'Autopilot not available.'

</code></pre></div>

print(tesla.start()) # from Vehicle

print(tesla.get_range()) # from ElectricVehicle

print(tesla.self_drive('Palo Alto')) # TeslaModel3's own method, using methods from ALL parents

</code></pre></div>

<div class="output-card"><pre><code>Tesla Model 3 is starting...

187 miles

Autopilot engaged. Routing to Palo Alto from 37.7749 N, 122.4194 W | Range: 187 miles

</code></pre></div>

<h3 id="53-multilevel-inheritance">5.3 Multilevel Inheritance</h3>

A chain, where each level adds more specific behavior than the one before it:

def breathe(self):

return 'Breathing oxygen.'

class Mammal(Animal): # Mammal IS an Animal

def feed_young_with_milk(self):

return 'Feeding young with milk.'

class Dog(Mammal): # Dog IS a Mammal (which is also an Animal)

def bark(self):

return 'Woof!'

</code></pre></div>

print(dog.breathe()) # inherited from Animal, two levels up

print(dog.feed_young_with_milk()) # inherited from Mammal, one level up

print(dog.bark()) # Dog's own method

print(isinstance(dog, Dog), isinstance(dog, Mammal), isinstance(dog, Animal))

</code></pre></div>

<div class="output-card"><pre><code>Breathing oxygen.

Feeding young with milk.

Woof!

True True True

</code></pre></div>

<code>isinstance()</code> confirming <code>True</code> all the way up the chain is the clearest proof that a <code>Dog</code> really is a <code>Mammal</code> and an <code>Animal</code> simultaneously, not just something that happens to share a few methods with them.

<h3 id="54-hierarchical-inheritance">5.4 Hierarchical Inheritance</h3>

Multiple children sharing one parent. This is the pattern a real bank actually needs: several account types, all built on the same core.

self.holder = holder

self.acc_no = acc_no

self.balance = balance

def __str__(self):

return f'{type(self).__name__} | {self.holder} | ${self.balance}'

class SavingsAccount(BankAccount):

interest_rate = 0.04

def apply_interest(self):

earned = self.balance * self.interest_rate

self.balance += earned

print(f'Interest earned: ${round(earned, 2)}. New balance: ${round(self.balance, 2)}')

class CurrentAccount(BankAccount):

overdraft_limit = 10000

if amount <= self.balance + self.overdraft_limit:

self.balance -= amount

print(f'Withdrew ${amount}. Balance: ${self.balance}')

else:

print('Amount exceeds overdraft limit.')

View remainder of file in raw view

FilesExpand file tree

8_OOPs_in_Python.html

Latest commit

History

8_OOPs_in_Python.html

File metadata and controls