Chapter 4 — Python Libraries

What is a Python library?
A Python library is a collection of prewritten code—modules and packages—that provides functions, classes and utilities to perform common tasks without rewriting code from scratch. Libraries speed development, improve reliability and let you use well-tested solutions.

Types of libraries

• Standard library: shipped with Python (examples: math, datetime, json).
• Third-party libraries: installed via package managers like pip (examples: numpy, pandas, matplotlib, requests).
• Domain-specific libraries: for web, data science, machine learning, etc. (examples: flask, scipy, sklearn).

How to install and import
Install with pip: pip install package_name (use virtual environments for projects). Import in code:

# import whole module
import math
# import with alias
import numpy as np
# import specific items
from math import sqrt, pi

Namespaces and aliasing
Using aliases (for example import numpy as np) keeps code readable and avoids long names. Modules create namespaces; use module.name to access items unless imported directly.

Why use libraries?

• Save time: reuse existing, tested code.
• Reliability: community-tested implementations.
• Performance: many libraries (e.g., NumPy) use optimized C code for speed.
• Readability and maintainability: high-level functions express intent clearly.

Simple examples (code)

# math: area of circle
from math import pi
def circle_area(r):
    return pi * r * r

# numpy: vectorized operations
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print('dot product =', np.dot(a, b))

# pandas: read CSV and show first rows
import pandas as pd
# df = pd.read_csv('data.csv')
# print(df.head())

# matplotlib: simple plot
import matplotlib.pyplot as plt
# plt.plot([1,2,3], [2,4,1])
# plt.show()

Best practices

• Use virtual environments (venv, conda) so project dependencies are isolated.
• Freeze dependencies with pip freeze > requirements.txt for reproducibility.
• Read official docs for correct usage and performance tips.
• Prefer high-level, well-maintained libraries for production code.

Common pitfalls

• Version incompatibilities: different projects may require different library versions.
• Name conflicts: avoid from module import * which can overwrite names.
• Overusing many libraries for small tasks can bloat projects.

Summary
Python libraries are fundamental building blocks that provide tested, reusable functionality. Learning how to discover, install, import and apply libraries is a key skill in Class 12 Computer Science and real-world programming.

What is a Module?

A module is a single Python file (with extension .py) that contains variables, functions, and classes which can be reused in other Python programs. Modules help organize code, avoid repetition, and provide namespaces.

Why use modules?

• Reusability: write once, use many times.
• Separation of concerns: group related functions together.
• Namespace management: avoid name conflicts.

Creating and using a simple module

Example file: calculator.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

PI = 3.14159

if __name__ == "__main__":
    # Code here runs only when module is executed directly
    print("Calculator test:", add(2, 3))

Using the module in another file:

import calculator
print(calculator.add(5, 4))

from calculator import add, PI
print(PI)

import calculator as calc
print(calc.subtract(10, 3))

Import forms (common)

• import module — imports module; access members with module.name.
• from module import name — imports specific names into the current namespace.
• from module import * — imports all public names (not recommended).
• import module as alias — gives module an alias.
• from package.subpackage import module — import from nested packages.

Module search and runtime behavior

• When you import a module, Python searches directories in sys.path in order: current directory, PYTHONPATH entries, standard library directories, site-packages.
• Imported modules are initialized once and cached in sys.modules. Subsequent imports reuse the cached module.
• Use importlib.import_module('name') for dynamic imports.

What is a Package?

A package is a way of structuring Python’s module namespace by using “dotted module names”. A package is a directory that contains one or more modules or subpackages. Historically, a package directory contains an __init__.py file (which can be empty) to mark it as a package. (PEP 420 introduced namespace packages that may omit __init__.py.)

Package structure example

utilities/              # top-level package
    __init__.py
    text_utils.py        # module
    math_utils.py
    io/
        __init__.py
        file_ops.py

Importing from the package:

from utilities import math_utils
from utilities.io.file_ops import read_file

Relative imports inside a package

# inside utilities/io/file_ops.py
from .. import math_utils       # one level up
from . import helper_module     # same package

Key special names and techniques

• __name__: a module’s name. If executed as main script, __name__ == "__main__".
• __all__: list of public names to export when from module import * is used.
• sys.path and sys.modules: inspect module search path and cache.
• pip install package_name: install third-party packages to site-packages.

Best practices

• Give modules short, meaningful names.
• Avoid from module import * to prevent name collisions.
• Keep packages logical and small; group related modules together.
• Use virtual environments for project-specific packages.

In summary: modules are single files for organizing code; packages are directories that group modules and subpackages to form larger libraries. Together they enable modular, maintainable Python programs.

What is a module? A module is a file containing Python definitions (functions, classes, variables) and statements saved with a .py extension. A package is a folder of modules with an __init__.py (or implicit namespace package).

Why import modules? Importing lets you reuse code written elsewhere (standard library, third-party or your own). It keeps programs modular, readable and maintainable.

How import works (high-level):

• When Python executes an import statement it: (1) locates the module, (2) compiles it to bytecode if needed, (3) executes it once creating a module object, and (4) caches it in sys.modules.
• Subsequent imports reuse the cached module (no re-execution) unless explicitly reloaded.

Common import forms (explanations and behavior):

• import module — import the module object; refer to members as module.name.
• import module as alias — give a shorter/alternate name to the module.
• from module import name1, name2 — import specific objects into current namespace.
• from module import * — import all public names (not recommended in large programs due to namespace pollution).
• from package import submodule and relative imports like from . import sibling or from ..subpackage import mod for packages.

Module search path: Python looks for modules in the order given by sys.path (script directory, PYTHONPATH entries, standard library directories, site-packages). You can view or modify sys.path at runtime if necessary.

Execution guard: To make a module both importable and executable as a script, use the idiom:

if __name__ == "__main__":
    # code that runs when module executed as a script

Reloading and dynamic import: Use importlib.reload(module) to reload an already imported module (useful in interactive sessions). Use importlib.import_module("modname") for dynamic import using a string module name.

Best practices:

• Prefer explicit imports (from module import name) or qualified imports (import module) over wildcard imports.
• Keep imports at the top of the file unless conditional imports are required for performance or to avoid circular imports.
• Avoid circular imports by reorganizing code (use local imports inside functions or extract shared code into a third module).
• Document third-party dependencies and manage them with pip and a requirements file.

Practical notes: Modules can define an __all__ list to control what from module import * brings into the namespace. Use dir(module) and help(module) for exploration.

What is a library? A library (or package) is a reusable collection of modules, functions, classes and resources that other programs can import and use. Creating and distributing libraries lets you share code, apply modular design, and benefit the Python ecosystem.

Why create a library?

• Reuse: avoid duplicate code across projects.
• Share: others can use, test and improve your work.
• Maintain: bug fixes and features delivered centrally.
• Professional practices: documentation, testing, versioning and packaging.

Basic steps to create and distribute a Python library

1. Design the package structure and write modules.
2. Add metadata: README, LICENSE, version number and dependencies.
3. Write tests and documentation.
4. Create build configuration (pyproject.toml or setup.cfg/setup.py).
5. Build distribution files: source distribution (sdist) and wheel (.whl).
6. Publish to an index (PyPI or a private index) using twine.
7. Install and use via pip.

Typical package structure

mypackage/            # repository root
  mypackage/           # package directory
    __init__.py
    core.py
    helpers.py
  tests/
    test_core.py
  README.md
  LICENSE
  pyproject.toml

Minimal pyproject.toml example

[build-system]
requires = ['setuptools', 'wheel']
build-backend = 'setuptools.build_meta'

[project]
name = 'mypackage'
version = '0.1.0'
description = 'Simple utility package'
readme = 'README.md'
license = {text = 'MIT'}
authors = [{name = 'Your Name', email = 'you@example.com'}]

Build and upload (commands)

• Build distributions: python -m build (creates dist/ folder with sdist and wheel)
• Upload to PyPI: python -m pip install --upgrade twine and python -m twine upload dist/*
• Install: pip install your-package-name

Using the published library

from mypackage import core
core.do_something()

Best practices and extra considerations

• Semantic versioning (MAJOR.MINOR.PATCH) for clear upgrade rules.
• Include a clear LICENSE (MIT, Apache, GPL, ...).
• Provide README, usage examples and API docs.
• Automate tests and releases with CI (GitHub Actions, GitLab CI).
• Use virtual environments when developing and testing.
• Pin dependencies minimally and state compatibility in metadata.

Testing & CI

Write unit tests (pytest or unittest), run them on each push, and run packaging checks (e.g., check wheel install in a clean environment). Configure automatic builds and uploads (for example, only on tagged releases).

Publishing options

• Public PyPI: for open-source distribution.
• Test PyPI: to test uploads before making them public.
• Private package indices or artifacts (for internal/proprietary code).

Security & maintenance

• Keep credentials (API tokens) secure (use CI secrets).
• Respond to issues and update dependencies to remove vulnerabilities.

The Python math module provides efficient, reliable mathematical functions and constants implemented in C. It is part of the standard library and is commonly used in Class 12 Computer Science for calculations involving trigonometry, logarithms, powers, rounding, combinatorics, and more. To use it: import math.

Key points:

• Constants: math.pi, math.e.
• Rounding and integer helpers: ceil, floor, trunc, fabs.
• Power and roots: sqrt, pow, exp.
• Logarithms: log (natural or base-n), log10, log2.
• Trigonometry: sin, cos, tan, and conversions radians/degrees. Also inverse functions asin, acos, atan2.
• Combinatorics & products (Python 3.8+): factorial, comb, perm, prod.
• Numeric utilities: gcd, lcm, hypot, fsum (accurate float sum), isfinite, isnan, isclose.

Examples of usage:

import math
# basic
r = 2.5
area = math.pi * r**2
# trig (angles in radians)
theta_deg = 30
theta = math.radians(theta_deg)
sin30 = math.sin(theta)
# distance and hypotenuse
d = math.hypot(3, 4)    # 5.0
# log / exp
val = math.log(10)      # natural log
# combinatorics
ways = math.comb(5, 2)  # 10 (choose 2 from 5)

Notes:

• Trigonometric functions expect radians; convert with math.radians() or math.degrees().
• Many functions raise ValueError for invalid domains (e.g., math.sqrt(-1)); use cmath for complex results.
• Use math.fsum instead of sum when high-precision floating-point accumulation is required.
• Prefer math.hypot for Euclidean distance to avoid overflow/underflow issues.

Overview: The Python random module provides functions to generate pseudo-random numbers and perform random selections. It is deterministic for a given seed (pseudo-random), so results can be reproduced using random.seed(). The module is commonly used for simulations, games, sampling, randomized algorithms and testing.

Key functions (short summary):

• random.random() — float in [0.0, 1.0)
• random.uniform(a, b) — float in [a, b] (continuous uniform)
• random.randint(a, b) — integer in [a, b] inclusive (discrete uniform)
• random.randrange(start, stop, step) — integer from range()
• random.choice(seq) — single element from sequence
• random.choices(population, weights=None, k=...) — list of k elements with optional weights (sampling with replacement)
• random.sample(population, k) — k unique elements (sampling without replacement)
• random.shuffle(list) — in-place random permutation of a list
• random.seed(a) — initialize generator for reproducible results
• random.gauss(mu, sigma) / random.normalvariate(mu, sigma) — draw from normal distribution

Behavior and notes:

• The module uses a deterministic algorithm (Mersenne Twister) by default; it is not suitable for cryptographic purposes — use secrets for secure randomness.
• seed() with the same argument produces the same sequence of values — useful for testing and demonstrations.
• For weighted or distributional sampling, use random.choices or draw from distribution-specific functions (e.g., gauss).

Short code examples:

# basic float
x = random.random()          # 0.0 <= x < 1.0

# integer and uniform
n = random.randint(1, 6)     # simulate a die (1 to 6)
y = random.uniform(-1, 1)    # continuous between -1 and 1

# choice, sample, shuffle
winner = random.choice(['A', 'B', 'C'])
team = random.sample(students, k=3)  # 3 distinct students
random.shuffle(deck)                   # shuffle a deck list

# reproducibility
random.seed(42)
print(random.random())

The Python statistics module (part of the standard library) provides functions to compute common statistical measures—mean, median, mode, variance, standard deviation, and more—on numeric data. It is intended for simple descriptive statistics on small to medium datasets. The module accepts any iterable of numbers (lists, tuples, etc.) and raises StatisticsError for empty inputs or undefined results (for example, mode on multimodal data).

Key functions:

• mean(data) — arithmetic mean (works with ints and floats).
• fmean(data) — faster floating-point mean (useful when performance matters).
• median(data), median_low, median_high — median for odd/even lengths; median_grouped for grouped data.
• mode(data), multimode(data) — most common value(s).
• pstdev(data), pvariance(data) — population standard deviation/variance (divide by n).
• stdev(data), variance(data) — sample standard deviation/variance (divide by n-1).
• geometric_mean(data), harmonic_mean(data) — means for multiplicative or rate-based data.
• covariance(x, y), correlation(x, y) — relationship between two numeric variables (added in recent Python versions).

Practical notes:

• Use fmean when you only need float precision and want speed for large iterables.
• Use population (pvariance/pstdev) when your data represent the entire population; use sample (variance/stdev) when your data are a sample from a larger population.
• mode raises StatisticsError if no unique mode exists; use multimode to get all modes.
• For robust descriptions of distributions, combine these statistics with visualisations (histograms, box plots, scatter plots).

Example code (quick reference):

import statistics as stats
data = [10, 20, 20, 30, 40]
print('mean:', stats.mean(data))
print('median:', stats.median(data))
print('mode:', stats.mode(data))
print('variance (sample):', stats.variance(data))
print('stdev (population):', stats.pstdev(data))
# covariance and correlation (if available)
x = [1, 2, 3, 4]
y = [2, 4, 5, 8]
print('covariance:', stats.covariance(x, y))
print('correlation:', stats.correlation(x, y))

Overview

The os and sys modules are part of Python's standard library and give programs access to operating system services and interpreter-level information. They are commonly used in scripts that interact with the filesystem, manage processes, or handle command-line arguments.

os module (Operating System interfaces)

• Purpose: Interact with the file system and environment (create/delete files and directories, examine file attributes, work with environment variables, run shell commands).
• Common categories of functionality:
• Filesystem navigation: os.getcwd(), os.chdir(path), os.listdir(path)
• Directory/file creation & removal: os.mkdir(name), os.makedirs(path), os.remove(path), os.rmdir(path)
• Path utilities (via os.path): os.path.join(a, b), os.path.exists(path), os.path.isfile(path), os.path.isdir(path), os.path.splitext(name), os.path.abspath(path)
• Environment & process: os.environ (mapping of environment variables), os.getenv('VAR'), os.system(cmd) (run a shell command)

sys module (Interpreter and runtime information)

• Purpose: Access data and functions that interact with the Python interpreter itself.
• Common uses:
• Command-line arguments: sys.argv (list of command-line strings; sys.argv[0] is the script name)
• Exit and status: sys.exit([status]) to terminate with an exit code
• I/O streams: sys.stdin, sys.stdout, sys.stderr
• Interpreter info: sys.version, sys.platform
• Module & path management: sys.modules, sys.path (list used for module search)
• Recursion control & limits: sys.getrecursionlimit(), sys.setrecursionlimit(n)

Key differences (quick)

• os talks to the operating system (files, directories, environment), while sys talks to the Python interpreter (arguments, I/O streams, import paths).
• They are often used together in scripts (e.g., read command-line args with sys.argv, then perform file operations with os).

Best practices

• Use os.path.join() instead of string concatenation to build paths so code works cross-platform.
• Prefer os.makedirs(path, exist_ok=True) when creating nested directories safely.
• Use sys.exit(code) to indicate success (0) or failure (nonzero) to the calling process.
• Use with open(...) for file handling; combine with os.path checks if needed.

Small example explanation

Typical flow: a Python script takes filenames from sys.argv, checks if they exist using os.path.exists(), processes them (reading/writing), and writes output to a directory created via os.makedirs(). This makes scripts portable and robust.

Overview: Python commonly uses three file/data formats for persisting and exchanging information: CSV (Comma Separated Values) for tabular data, JSON (JavaScript Object Notation) for structured text data interoperable across languages, and Pickle for Python-native binary serialization of arbitrary objects. Each has a dedicated module: csv, json, and pickle.

CSV (csv module): CSV is plain-text, row/column oriented. The csv module helps read/write rows as lists or dictionaries. Use csv.reader/csv.writer for list-of-values and csv.DictReader/csv.DictWriter for mapping column names to values. Important: open files with newline='' in Python to avoid extra blank lines on Windows. CSV is best for spreadsheets, logs, and simple tabular export/import. Limitations: no nested structures or native types (everything is text), so numbers/dates require conversion.

JSON (json module): JSON is a text format representing objects (dicts), arrays (lists), strings, numbers, booleans and null. Python maps JSON objects to dict, arrays to list, true/false to True/False, and null to None. Use json.dump/json.load for files and json.dumps/json.loads for strings. JSON is language-independent and common in web APIs, configuration files, and data interchange. Limitations: cannot represent arbitrary Python objects (like custom class instances) without conversion.

Pickle (pickle module): Pickle converts (serializes) nearly any Python object to a binary byte stream and back (deserialization). Use pickle.dump(obj, file) and pickle.load(file) with files opened in binary mode ('wb', 'rb'). Pickle is convenient for caching models, session state, or complex Python objects. Major caution: unpickling data from untrusted sources is a security risk (it can execute arbitrary code). Pickle format is Python-specific and generally not interoperable with other languages.

When to use which:

• CSV: simple tabular data, human-readable spreadsheets, CSV import/export.
• JSON: structured data for configuration, web APIs, exchange between systems.
• Pickle: fast persistence of Python-only complex objects, ML models, caches (only when data source is trusted).

Practical tips:

• CSV: specify delimiter, quotechar, and use DictReader/DictWriter for column names.
• JSON: use indent to pretty-print, set ensure_ascii=False for non-ASCII text, and convert non-JSON types (e.g., datetime) to strings or custom encoders.
• Pickle: choose protocol (default is fine), always open files in binary mode, never unpickle data from the network or untrusted files.

Security & Interoperability: JSON and CSV are text formats suitable for inter-system exchange. Pickle is internal to Python and unsafe across untrusted boundaries.

What are regular expressions? Regular expressions (regex) are compact patterns used to match, search, and manipulate text. In Python the re module provides functions to work with regex: match, search, findall, finditer, sub, split, and compile.

Key concepts

• pattern: the regex string that describes what to search for.
• Character classes (e.g. \d, \w, \s) and custom classes (e.g. [A-Za-z0-9]).
• Anchors: ^ (start of string/line), $ (end of string/line).
• Quantifiers: *, +, ?, {m,n} (how many times an element repeats).
• Groups and capturing: (...) capture subpatterns; (?:...) is a non-capturing group.
• Greedy vs non-greedy: * and + are greedy by default; add ? to make them non-greedy (e.g. .*?).
• Flags: re.IGNORECASE (re.I), re.MULTILINE (re.M), re.DOTALL (re.S).

Common functions

• re.match(pattern, text): checks for a match at the beginning of text.
• re.search(pattern, text): searches anywhere in text for the first match.
• re.findall(pattern, text): returns a list of all non-overlapping matches (strings or tuples if groups present).
• re.finditer(pattern, text): returns an iterator of match objects (useful to get positions).
• re.sub(pattern, repl, text): substitutes matches with repl.
• re.split(pattern, text): splits text around matches.
• re.compile(pattern, flags): compiles a pattern into a regex object for repeated use (better performance).

Best practices

• Use raw string literals for patterns: r"\d+", so backslashes are not processed by Python string escapes.
• Use re.escape() when inserting literal text into patterns.
• Compile frequently used patterns with re.compile() to improve performance.
• Aim to anchor patterns (^, $) when possible to avoid accidental slow backtracking.

What is tkinter?
tkinter is Python's standard library for creating graphical user interfaces (GUIs). It provides a thin object-oriented layer on top of Tcl/Tk. With tkinter you build windows, dialogs and widgets (buttons, labels, text entry, canvas, menus) and handle user events in an event-driven loop.

Key concepts

• Root window: The main application window created with Tk().
• Widgets: UI elements such as Label, Button, Entry, Text, Frame, Canvas, Menu.
• Geometry managers: Control placement using pack(), grid(), or place().
• Event-driven programming: The program waits for events (clicks, keypresses) and calls callback functions. The loop is started with mainloop().
• Control variables: StringVar, IntVar, BooleanVar connect widget state to Python variables for two-way updates.

Basic structure (typical program)

import tkinter as tk

root = tk.Tk()               # create main window
root.title('My App')
root.geometry('300x200')     # optional: set size

label = tk.Label(root, text='Hello')
label.pack()                 # use a geometry manager

button = tk.Button(root, text='Click', command=lambda: print('clicked'))
button.pack()

root.mainloop()              # start event loop

Widgets & common options

• Label(parent, text='...') — display text or images.
• Button(parent, text='...', command=callback) — clickable button.
• Entry(parent) — single-line input; use .get() to read.
• Text(parent) — multi-line text area.
• Listbox, Radiobutton, Checkbutton — selection widgets.
• Canvas(parent) — draw shapes, handle mouse drawing and simple games.
• Menu — application menus and context menus.

Geometry managers

• pack() — simple stacking (top/bottom/left/right); options: side, fill, expand.
• grid() — place widgets in rows and columns; good for forms and calculators.
• place() — absolute positioning (x, y) and relative sizes; less commonly used for responsive UIs.

Event binding & callbacks

# Button uses 'command' for click
button = tk.Button(root, text='OK', command=on_ok)

# Generic event binding (mouse, keyboard)
root.bind('', on_enter)    # on_enter(event) will be called
canvas.bind('', on_click)

Common additions

• messagebox: showinfo, showwarning, askyesno for dialogs.
• filedialog: askopenfilename, asksaveasfilename for file selection.
• ttk: Themed tkinter widgets (ttk.Button, ttk.Label) for modern look.

Event loop model (brief)
Tkinter runs a loop that waits for user or system events and dispatches them to your callback functions. Your callbacks should be short and non-blocking; long tasks should run in threads or use asynchronous techniques.

Good practices

• Use grid() for form-like layouts (avoid mixing pack() and grid() in same container).
• Keep UI responsive: avoid heavy computation in callback directly.
• Use StringVar/IntVar where widgets need to share state.
• Organize UI into Frames for clarity and reuse.

Short complete example — simple calculator UI (layout only)

import tkinter as tk

root = tk.Tk()
root.title('Calculator')

entry = tk.Entry(root, width=16, justify='right')
entry.grid(row=0, column=0, columnspan=4)

buttons = [
    ('7',1,0), ('8',1,1), ('9',1,2), ('/',1,3),
    ('4',2,0), ('5',2,1), ('6',2,2), ('*',2,3),
    ('1',3,0), ('2',3,1), ('3',3,2), ('-',3,3),
    ('0',4,0), ('.',4,1), ('=',4,2), ('+',4,3),
]
for (text,r,c) in buttons:
    tk.Button(root, text=text, width=4).grid(row=r, column=c)

root.mainloop()

Overview

The Python turtle module provides a simple drawing/graphics environment that is ideal for teaching programming, geometry and animation. It models a pen (the turtle) that moves on a 2D canvas: commands move the turtle and draw lines.

How it works (core concepts)

• Turtle and Screen: Create a Screen object (the window/canvas) and one or more Turtle objects (the pens that draw).
• Movement commands: forward(dist), backward(dist), left(angle), right(angle), goto(x, y).
• Pen control: penup()/pendown(), pensize(), pencolor(), and fill control with begin_fill()/end_fill().
• Drawing arcs/circles: circle(radius, extent=None) draws circular arcs (extent in degrees).
• Heading and coordinates: Default heading is 0° (pointing east). Angles increase counterclockwise: 90° points north. The screen origin (0,0) is the center by default.
• Animation control: speed(), tracer()/update() for fast drawing.
• Interactivity: onclick(), onkey(), textinput() support event-driven programs.

Coordinate system & orientation

• Origin (0,0) is centered by default (can be changed with setworldcoordinates()).
• X increases to the right, Y increases upward.
• Heading 0° → east (right), 90° → north (up), 180° → west (left), 270° → south (down).

Useful tips

• Use tracer(0) and update() to draw many shapes quickly without animation overhead.
• Use multiple turtles to draw different parts concurrently (or to keep pens with different styles).
• Use begin_fill()/end_fill() to draw filled shapes.
• Use clear() to erase drawing (keeping turtle state) and reset() to reset the turtle.

Where it's useful (real-life / pedagogic examples)

• Teaching geometry: visualize polygons, angles, symmetry, transformations (translation/rotation/scaling).
• Algorithm visualization: show pathfinding, recursion (fractal trees, Koch snowflake), sorting algorithms pictorially.
• Simple GUIs and interactive games: click-to-draw, turtle-controlled games.
• Art and design: generative art, spirographs, colourful spirals and patterns.

Minimal example (draw a square)

import turtle
screen = turtle.Screen()
pen = turtle.Turtle()
for _ in range(4):
    pen.forward(100)
    pen.right(90)
screen.mainloop()

Performance/animation example

To draw complex patterns fast, disable animation and update at the end:

screen.tracer(0)
# ... many drawing operations ...
screen.update()

Overview
Package management with pip and virtual environments (venv/virtualenv) are essential for managing third‑party Python libraries and isolating project dependencies. pip installs, uninstalls, lists and inspects packages. Virtual environments create per‑project, isolated Python runtimes so packages and versions for one project don't interfere with others or the system Python.

Why use them?

• Avoid version conflicts: two projects can require different versions of the same library (for example, Django 2.x vs 3.x).
• Reproducibility: using requirements.txt ensures other developers or deployment servers can install the same package set.
• Safety: do not modify system Python packages which may be used by OS components.

Common tools/commands

• python -m venv env — create a virtual environment named env (builtin in Python 3).
• source env/bin/activate (Linux/macOS) or env\Scripts\activate (Windows) — activate venv.
• deactivate — leave the virtual environment.
• pip install package — install a package into the active environment.
• pip install -r requirements.txt — install packages listed in a requirements file.
• pip freeze — show exact package versions (useful to create requirements.txt).
• pip list, pip show package, pip uninstall package, pip install --upgrade package.

Typical workflow

1. Create a venv:

   python -m venv myenv

2. Activate it:

   source myenv/bin/activate  # macOS/Linux
   myenv\Scripts\activate     # Windows

3. Install packages:

   pip install requests pandas

4. Freeze exact versions:

   pip freeze > requirements.txt

5. Share requirements.txt; others run:

   pip install -r requirements.txt

6. When done:

   deactivate

Dependency resolution
When you install a package, pip will resolve and download dependencies (other packages required). The result is a dependency graph where nodes are packages and directed edges mean "requires". Conflicts occur when two packages require incompatible versions of the same dependency; tools or manual changes are needed to resolve them.

Best practices

• Create one virtual environment per project.
• Use pip freeze > requirements.txt for deployment / sharing.
• Prefer exact pinned versions for production (package==x.y.z) and looser ranges (>=, ~=) during development where appropriate.
• Keep pip updated: python -m pip install --upgrade pip.
• For complex dependency management consider higher‑level tools (pipenv, poetry) which add lockfiles and workspace management.

Notes for CBSE exam style
Be able to write commands, explain purpose of venv and pip, and to show how to create, activate, install, freeze, and deactivate an environment. Explain with a small example workflow and the role of requirements.txt.

What are third-party libraries? Third-party libraries are pre-written packages created by the community that extend Python's capabilities (for data handling, plotting, web access, machine learning, image processing, etc.). They are not part of the Python standard library and are usually installed using pip (for example: pip install numpy).

Why use them?

• Save time: provide well-tested functions and data structures.
• Specialised functionality: numerical computing, visualization, ML, web scraping, image I/O.
• Interoperability: many libraries work together (e.g., pandas + matplotlib + scikit-learn).

Overview of commonly used third-party libraries (Class 12 focus)

• NumPy — numerical arrays, vectorized operations, linear algebra. Use for fast number crunching and array math.
• pandas — tabular data structure (Series, DataFrame), data cleaning, grouping and aggregation.
• matplotlib — basic plotting library for line, bar, scatter, histogram, etc.
• seaborn — statistical data visualization built on matplotlib; easier attractive plots like heatmaps and boxplots.
• scipy — scientific computing: integration, optimization, signal processing (built on NumPy).
• scikit-learn — machine learning: classification, regression, clustering, model selection and evaluation.
• requests — simple HTTP library for making web requests (APIs, REST calls).
• BeautifulSoup (bs4) — HTML/XML parsing for web scraping (extracting content from web pages).
• Pillow (PIL) — image processing: open, resize, save, basic transforms.
• OpenCV (cv2) — advanced image and video processing, computer vision tasks.
• Flask — lightweight web framework for building simple web apps and APIs (useful for deploying models).

How they are typically used together

• Load tabular data with pandas, compute numeric arrays with NumPy, plot results with matplotlib/seaborn.
• Scrape web data with requests + BeautifulSoup, store in pandas DataFrame, clean and visualize.
• Preprocess data with pandas/numpy, train models with scikit-learn, evaluate and plot metrics with matplotlib.

Best practices

• Read official docs and examples for each library.
• Use virtual environments (venv) to avoid dependency conflicts.
• Prefer vectorized NumPy/pandas operations over Python loops for performance.

Overview: Best practices, documentation and error handling together make Python code maintainable, readable and robust. Best practices guide how you write and structure code; documentation explains how to use it; error handling ensures graceful responses to runtime problems.

Best Practices (concise):

• Follow style conventions — use PEP 8 naming, indentation and line length for readability.
• Modular design — split code into small functions and modules (single responsibility).
• Use virtual environments and pin dependencies (requirements.txt or Pipfile) to ensure reproducible environments.
• Avoid code duplication (DRY) — reuse functions and utilities.
• Write tests — unit tests for logic, integration tests for components; run tests automatically (CI).
• Prefer clear names and docstrings — descriptive function/variable names and module/function docstrings.
• Use version control (git) and semantic versioning for libraries.
• Use logging instead of print for runtime diagnostics and configurable verbosity.
• Handle resources safely — use context managers (with) for files, network connections, DB transactions.

Documentation:

• Docstrings — every module, class and public function should have a docstring describing purpose, parameters, return values and exceptions. Use e.g., Google/Numpy/Sphinx style consistently.
• README — quick start, installation, examples and license.
• API Reference — auto-generate with Sphinx or pdoc from docstrings.
• Examples and tutorials — short runnable examples that show common use-cases.
• CHANGELOG — document breaking changes and feature additions across versions.
• Type hints — optional static typing (PEP 484) improves readability and tooling support.

Error Handling:

• Use try/except/else/finally to catch and handle anticipated errors. Avoid bare except:; catch specific exceptions.
• Raise informative exceptions with clear messages; create custom exception classes when needed.
• Clean up resources in finally or use context managers to ensure deterministic cleanup.
• Log exceptions with traceback for debugging; present user-friendly messages to end users.
• Fail fast for programming errors (let assertions or exceptions surface) and catch only expected runtime errors (I/O, network, user input).
• Validate inputs early to avoid deep failures later (defensive programming).
• Graceful degradation — where possible, provide fallback behaviour rather than crashing.

Why this matters: Well-documented, well-structured code with robust error handling reduces bugs, eases collaboration, speeds onboarding and improves user trust.

Quick example of good structure (HTML-preserved):

<!-- Module: file_utils.py -->
"""
file_utils — small utilities for reading configuration files.

Functions
---------
read_config(path: str) -> dict
    Read JSON config from the given path and return a dict.
"""

import json
import logging
from typing import Dict

logger = logging.getLogger(__name__)

class ConfigError(Exception):
    """Raised when configuration cannot be loaded."""


def read_config(path: str) -> Dict:
    """Read JSON configuration from path.

    Args:
        path: Path to the JSON config file.

    Returns:
        Parsed configuration dictionary.

    Raises:
        ConfigError: If file not found or JSON is invalid.
    """
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except FileNotFoundError as e:
        logger.exception("Config file not found: %s", path)
        raise ConfigError(f"Config file not found: {path}") from e
    except json.JSONDecodeError as e:
        logger.exception("Invalid JSON in config: %s", path)
        raise ConfigError(f"Invalid JSON in config: {path}") from e