The Class 11 Computer Science Book Informatics Practices is the NCERT textbook with 8 chapters and 174 printed pages, and every chapter’s official PDF is in the table below. Working with Python, lists and dictionaries, NumPy, database concepts and SQL are all inside this one book.
This page also carries a chapter-wise directory of what the book contains: named sections, activities, indexed figures and end-of-chapter questions, each with the page it starts on. You can see which chapter is theory and which is code before opening the PDF, and all links point to the current NCERT editions on ncert.nic.in.
Download the Class 11 Computer Science Book Informatics Practices PDF
All files are NCERT’s own, hosted on the official NCERT website at ncert.nic.in, which publishes and hosts the current editions of every NCERT textbook including this one.
| Ch. | Chapter | Pages | Official PDF |
|---|---|---|---|
| 1 | Computer System Chapter 1 | 14 | |
| 2 | “Computer science is no more about computers than astronomy is about telescopes” | 16 | |
| 3 | — G. van Rossum | 24 | |
| 4 | Working with Lists and Dictionaries | 26 | |
| 5 | “Data is not information, Information is not knowledge, Knowledge is not understanding, Understanding is not wisdom.” | 14 | |
| 6 | INTRODUCTION CHAPTER TO NUMPy 6 | 28 | |
| 7 | Database Chapter | 20 | |
| 8 | – E. F. Codd | 32 |
Class 11 Computer Science NCERT PDF at a Glance
These numbers describe the whole book in one screen:
- 8 chapters — from Computer System to Introduction to Structured Query Language (SQL), each with an official PDF in the table above.
- 174 printed pages across the eight chapter files.
- 134 named sections — the numbered headings a revision plan can hang on.
- 21 activities for hands-on work, 9 of them inside the final SQL chapter.
- 32 verified numbered figures indexed from the textbook, most of them in the two opening chapters.
What’s Inside Each Chapter: Sections, Figures and Questions
| Ch. | Chapter | Sections | Activities | Figures | Questions |
|---|---|---|---|---|---|
| 1 | Computer System Chapter 1 | 12 | 4 | 9 | 11 |
| 2 | “Computer science is no more about computers than astronomy is about telescopes” | 16 | 5 | 13 | 15 |
| 3 | — G. van Rossum | 27 | — | 4 | 11 |
| 4 | Working with Lists and Dictionaries | 19 | — | — | 8 |
| 5 | “Data is not information, Information is not knowledge, Knowledge is not understanding, Understanding is not wisdom.” | 7 | 1 | 2 | — |
| 6 | INTRODUCTION CHAPTER TO NUMPy 6 | 22 | 2 | — | 10 |
| 7 | Database Chapter | 11 | — | 3 | 10 |
| 8 | – E. F. Codd | 20 | 9 | 1 | 10 |
The directory above counts four kinds of content. A section is one of NCERT’s numbered headings in that chapter; a figure is a numbered figure printed in the chapter; an activity is a hands-on task set inside the chapter; and a question is an end-of-chapter exercise. The notes below each chapter compare them in prose.
Chapter 1: Computer System (pp. 1-14)
The chapter’s summary defines a computer in one line: it is a computing device that processes input data under given instructions to produce the desired output. That processing turns raw data into information, and the chapter’s job is to introduce the parts of the machine that do it.
It covers the central processing unit, input and output devices, memory and software.
- Introduction to Computer System (p. 1) — the CPU, input devices and output devices
- Evolution of Computer (p. 3)
- Computer Memory (p. 5) — units and types of memory
- Software (p. 9) — system software and application software
With 12 named sections, 4 activities, 9 indexed figures and 11 exercise questions, it is the hardware-and-software foundation the rest of the book builds on.
Chapter 2: Emerging Trends (pp. 15-30)
Artificial intelligence, the summary opens, tries to simulate the natural intelligence of human beings into machines, making them intelligent. Machine learning is the part built from algorithms that use data to learn on their own. The same idea — technology that senses, learns or works for us — runs through big data, the Internet of Things, cloud computing and blockchain.
- Introduction to Emerging Trends (p. 15)
- Artificial Intelligence (AI) (p. 16) — machine learning, NLP, immersive experiences, robotics
- Big Data (p. 19) — its characteristics and data analytics
- Internet of Things (IoT) (p. 21) — Web of Things, sensors, smart cities
- Cloud Computing (p. 23) — cloud services
- Blockchains (p. 26)
With 16 named sections, 5 activities, 13 indexed figures and 15 exercise questions, it is the most figure-heavy chapter in the book — its diagrams carry the teaching of AI, big data, IoT, cloud computing and blockchain.
Chapter 3: Brief Overview of Python (pp. 31-54)
The summary positions Python first: it is an open-source, high-level, interpreter-based language, usable for scientific and non-scientific computing. It then makes the point every beginner needs — comments are non-executable statements in a program. The chapter builds the language from the ground up, from keywords and variables to expressions, debugging, functions, if-else and loops.
- Introduction to Python (p. 31) — working with Python and its execution modes
- Python Keywords (p. 34)
- Identifiers (p. 34)
- Variables (p. 34)
- Data Types (p. 35) — number and sequence types
- Operators (p. 38) — arithmetic, relational, assignment, logical and membership
- Expressions (p. 41) — precedence of operators
- Input and Output (p. 42)
- Debugging (p. 43) — syntax, logical and runtime errors
- Functions (p. 44)
- if..else Statements (p. 46)
- For Loop (p. 48) — the range() function
- Nested Loops (p. 50)
With 27 named sections in 24 pages — the widest chapter in the book — and only 4 figures, no activities and 11 exercise questions, it teaches almost entirely through code listings: keywords, identifiers, variables, data types, five operator families, expressions, debugging, functions, if-else, for loops and nested loops.
Chapter 4: Working with Lists and Dictionaries (pp. 55-80)
The summary highlights three list behaviours: two-way indexing lets you traverse a list forward and backward; the + operator concatenates one list to the end of another; and * repeats a list’s content by a specified amount. The same treatment then moves to dictionaries, which the chapter presents as mutable key-value structures.
- Introduction to List (p. 55) — accessing elements and mutability
- List Operations (p. 57) — concatenation, repetition, membership, slicing
- Traversing a List (p. 59)
- List Methods and Built-In Functions (p. 60)
- List Manipulation (p. 62)
- Introduction to Dictionaries (p. 67) — creation, accessing items, membership
- Traversing a Dictionary (p. 69)
- Dictionary Methods and Built-In Functions (p. 69)
- Manipulating Dictionaries (p. 71)
With 19 named sections, no figures, no activities and 8 exercise questions, this is the methods-and-code chapter — the concepts are taught through short programs, not diagrams.
Chapter 5: Understanding Data (pp. 81-94)
The summary defines data plainly: data are unorganised facts that can be processed to generate a meaningful result, or information.
It separates data into structured and unstructured types, names the storage devices the chapter examines — hard disk, SSD, CD/DVD, pen drive, memory card — and moves on to the steps of data processing and the statistical techniques used to summarise data.
- Introduction to Data (p. 81) — importance and types of data
- Data Storage (p. 86)
- Data Processing (p. 87)
- Statistical Techniques for Data Processing (p. 88) — measures of central tendency
With just 7 named sections, 2 indexed figures and 1 activity, this is the book’s concept-only chapter: it defines data, separates structured from unstructured data, and ends with measures of central tendency.
Chapter 6: Introduction to NumPy (pp. 95-122)
The summary’s base definition is the array: a data type that holds objects of the same data type, stored contiguously in memory, with every element reachable through an index. NumPy is the Python library built for this array-based numerical work.
The chapter walks through creating arrays from lists, indexing and slicing them, arithmetic operations, reshaping and splitting, statistics, and loading and saving array files.
- Introduction (p. 95)
- Array (p. 96)
- NumPy Array (p. 96) — list vs array, creation, attributes
- Indexing and Slicing (p. 100)
- Operations on Arrays (p. 102) — arithmetic, transpose, sorting
- Concatenating Arrays (p. 104)
- Reshaping Arrays (p. 105)
- Splitting Arrays (p. 106)
- Statistical Operations on Arrays (p. 107)
- Loading Arrays from Files (p. 109) — loadtxt() and genfromtxt()
- Saving NumPy Arrays in Files on Disk (p. 112)
With 22 named sections, 2 activities and 10 exercise questions — and no figures — the chapter teaches through code and its output, so the learning happens by reading and running programs.
Chapter 7: Database Concepts (pp. 123-142)
The summary starts where databases start: a file in a file system is a container for storing data in a computer. It lists the file system’s failures — data redundancy, data inconsistency, data isolation, data dependence and limited controlled data sharing — and then brings in the database management system as the proper way to manage related data.
The relational model and its keys follow.
- Introduction (p. 123)
- File System (p. 124) — its limitations
- File System to DBMS (p. 128)
- Key Concepts in DBMS (p. 130)
- Three Important Properties of a Relation (p. 135)
- Keys in a Relational Database (p. 136) — candidate, primary, composite primary and foreign keys on pp. 136-137
With 11 named sections, 3 indexed figures and 10 exercise questions, it builds the database vocabulary — including the four key types — that the SQL chapter assumes.
Chapter 8: Introduction to Structured Query Language (SQL) (pp. 143-174)
The summary gives the three definitions the chapter runs on: a database is a collection of related tables, MySQL is a relational DBMS, and SQL is the standard language for defining and manipulating data. A table is rows and columns, where each row is a record and the columns describe the features of those records.
The chapter then works through the actual MySQL commands, from CREATE and INSERT to SELECT, UPDATE and DELETE.
- Introduction (p. 143)
- Structured Query Language (SQL) (p. 144) — installing MySQL
- Data Types and Constraints in MySQL (p. 145)
- SQL for Data Definition (p. 146) — CREATE, DESCRIBE, ALTER, DROP
- SQL for Data Manipulation (p. 153) — insertion of records
- SQL for Data Query (p. 156) — SELECT and querying the OFFICE database
- Data Updation and Deletion (p. 166)
With 20 named sections, 9 activities, 10 exercise questions and just 1 figure, it is the longest chapter at 32 pages — and it carries 9 of the book’s 21 activities, so the hands-on work concentrates at the end of the book.
Chapter Study Pages for This NCERT Book
The table below shows each chapter’s study page on this site, with its current status — available chapters are linked directly, and chapters still in the works are marked as coming soon rather than left unlinked.
| Ch. | Chapter page |
|---|---|
| 1 | Computer System Chapter 1 (coming soon) |
| 2 | “Computer science is no more about computers than astronomy is about telescopes” (coming soon) |
| 3 | — G. van Rossum (coming soon) |
| 4 | Working with Lists and Dictionaries (coming soon) |
| 5 | “Data is not information, Information is not knowledge, Knowledge is not understanding, Understanding is not wisdom.” (coming soon) |
| 6 | INTRODUCTION CHAPTER TO NUMPy 6 (coming soon) |
| 7 | Database Chapter (coming soon) |
| 8 | – E. F. Codd (coming soon) |
How to Use the Class 11th Computer Science Book
This book is really three smaller books, and they do not have to be read in printed order. The three tracks below are the fastest way to see the shape of the book:
| Track | Chapters | What you learn |
|---|---|---|
| Computer system concepts | 1, 2 | the machine — CPU, memory and software — then AI, big data, IoT, cloud and blockchain |
| Python programming | 3, 4, 6 | the Python language, then lists and dictionaries, then NumPy arrays |
| Data and databases | 5, 7, 8 | what data is, the relational model and keys, then SQL commands |
The Python chapters must be read in the order 3 → 4 → 6. Lists and dictionaries assume the Python of Chapter 3, and NumPy arrays assume list skills from Chapter 4. Chapters 7 and 8 form a self-contained database unit that starts with file system limitations and keys, then moves to MySQL commands from CREATE and INSERT through SELECT, UPDATE and DELETE.
That unit does not depend on any Python chapter.
The common mistake is to jump to Chapter 6 or Chapter 8 first. Chapter 6 assumes you can already build and index a list from Chapter 4; Chapter 8 assumes the database vocabulary of Chapter 7. Read the tracks in order once and the chapters stop feeling disconnected.
| Mistake | Correct rule | How to check your answer |
|---|---|---|
| Jumping to NumPy before Python basics | Read 3 → 4 → 6 in order | Try the Chapter 4 exercises; if lists feel new, go back to Chapter 3 |
| Treating the database unit as if it needs Python | Chapters 7 and 8 stand alone; SQL is its own language | Read Chapter 7, then open MySQL and run the Chapter 8 examples |
| Reading SQL instead of running it | Type each command into MySQL as you go | Install MySQL (Ch 8, p. 144) and reproduce the chapter’s CREATE and SELECT examples |
Textbook contents and the examinable syllabus are not always identical — check the current official CBSE syllabus before deciding what to revise.
How to Choose What to Study in the Computer Science Class 11 Textbook PDF
Depending on how much time you have before the exam or practical, different chapters earn different priority:
- One night, theory only: start with Chapters 7 and 8, because the database unit does not depend on the Python chapters, then revise Chapter 2 for theory terms such as AI, big data and IoT.
- One night, code practice: Chapter 4 (lists and dictionaries) or Chapter 6 (NumPy) — short programs you can type and run quickly.
- Practical or SQL revision: Chapters 3, 7 and 8 — Python basics for the practical file, then the database unit for SQL commands.
- Long-term order: 1 → 2 → 3 → 4 → 6 → 5 → 7 → 8 — the machine first, then Python, then data.
If you came here with one topic in mind, this lookup gets you to the right chapter directly:
| You are looking for | Go to |
|---|---|
| A computer’s parts, memory and software | Chapter 1 |
| AI, big data, IoT, cloud computing, blockchain | Chapter 2 |
| Python basics — keywords, operators, loops | Chapter 3 |
| Lists and dictionaries | Chapter 4 |
| What data is and how to summarise it | Chapter 5 |
| NumPy arrays | Chapter 6 |
| Databases and keys | Chapter 7 |
| SQL commands | Chapter 8 |
Related Resources
This listing is maintained for the 2026-27 academic session using the NCERT textbook information available to us. NCERT remains the authority for confirming the latest edition.
The rest of the NCERT books directory is one step away from this page:
- All NCERT books by class — the directory root for every textbook on this site
- Class 11 NCERT books hub — every Class 11 subject book in one place
- Class 12 NCERT books hub — the next class, for students planning ahead
Sources and Data Verification
- This page describes the NCERT Class 11 Informatics Practices textbook — used here as the Class 11 Computer Science book — chapters 1 to 8, from the official editions on ncert.nic.in (files keip101 to keip108).
- It covers only the eight chapters listed above. It does not cover the wider CBSE scheme of studies, which includes more subjects than this book.
- The listing is maintained for the current NCERT editions available on ncert.nic.in.
- NCERT settles textbook titles, editions and PDFs. CBSE settles the curriculum, syllabus and examinations — and textbook contents and the examinable syllabus are not always identical, so check the current official CBSE syllabus.
Reference: NCERT Class 11 Computer Science (Informatics Practices) textbook, official edition on ncert.nic.in. Figure captions and section titles quoted from the textbook; page references are to the official PDF.
Frequently Asked Questions About This Book
How many chapters are in the Class 11 Computer Science Book Informatics Practices?
Eight chapters across 174 printed pages. They run from Computer System (Chapter 1) through Emerging Trends, Python, lists and dictionaries, data, NumPy and database concepts, ending with Structured Query Language (SQL) in Chapter 8.
Is the Class 11 Computer Science (Informatics Practices) PDF official and free?
Yes. Each chapter PDF in the table above is NCERT’s own file, hosted on ncert.nic.in, and downloading it costs nothing. The official file codes are keip101 to keip108.
Which chapter covers Python in this Class 11 computer science book?
Python itself is Chapter 3, Brief Overview of Python. Lists and dictionaries follow in Chapter 4, and NumPy arrays in Chapter 6 — read them in that order because each assumes the one before it.
Which chapters cover databases and SQL?
Chapter 7, Database Concepts, covers file systems, the relational model and keys. Chapter 8 covers SQL for MySQL, from CREATE and INSERT through SELECT, UPDATE and DELETE.
Where do artificial intelligence, big data and IoT appear in this book?
In Chapter 2, Emerging Trends. It covers AI with machine learning and natural language processing, big data, the Internet of Things, cloud computing and blockchain — the chapter in the book with the most diagrams.