Overview

Python is a programming language that is easy to read and write, which makes it a great choice for beginners. At the same time, it is powerful enough for professionals working in web development, data science, machine learning, automation, and much more.

Install Python using uv

Windows

1. Install Scoop

   Open PowerShell and run:

   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
   irm get.scoop.sh | iex

   Official site: https://scoop.sh

2. Install uv

   scoop install uv

3. Verify installation

   uv --version

4. Install Python

   uv python install 3.12

Linux / macOS

1. Install uv

   curl -LsSf https://astral.sh/uv/install.sh | sh

2. Verify installation

   uv --version

3. Install Python

   uv python install 3.12

Important uv Commands

uv init my-project                       # create project
uv venv                                  # create virtual environment
uv pip install <package>                 # install package
uv pip uninstall <pkg>                   # remove package
uv pip freeze                            # list installed packages
uv run python main.py                    # run script
uv pip compile                           # lock dependencies
uv pip sync                              # install exact dependencies
uv pip show <package>                    # show package info
uv run --python <version> <command>      # run command with specific Python version
uv export --no-hashes > requirements.txt # export dependencies to requirements.txt

Introduction to Coding World with Python

Start here if you are brand new to Python. This section helps you understand how Python works and how to actually run your code.

• Python overview - simple, readable, and beginner-friendly
• Installation and setup using uv
• Running code:
  • REPL (an interactive shell where you type and run code line by line)
  • Script execution (writing code in .py files and running them)

print("Hello, World!")

Project Structure

As your project grows, it helps to organise your files in a clear way so they are easy to find and maintain.

my_project/
│
├── pyproject.toml # Project config (uv + dependencies)
├── uv.lock # Auto-generated lock file
├── README.md
├── .gitignore
├── .env # Environment variables
│
├── src/ # Main source code (recommended layout)
│ └── my_project/
│ ├── **init**.py
│ ├── main.py # Entry point
│ │
│ ├── core/ # Core logic (business logic)
│ │ ├── **init**.py
│ │ └── config.py # Settings, env handling
│ │
│ ├── services/ # External interactions / logic layer
│ │ ├── **init**.py
│ │ └── api.py
│ │
│ ├── models/ # Data models
│ │ ├── **init**.py
│ │ └── user.py
│ │
│ ├── utils/ # Helper functions
│ │ ├── **init**.py
│ │ └── helpers.py
│ │
│ └── db/ # Database layer
│ ├── **init**.py
│ └── sqlite.py
│
├── tests/ # Testing (pytest)
│ ├── **init**.py
│ ├── test_main.py
│ ├── test_services.py
│ └── conftest.py # Fixtures
│
├── scripts/ # CLI / automation scripts
│ └── run.py
│
└── logs/ # Log files (optional)

Data Types in Python

In Python, every piece of data has a type. Understanding types is one of the most important foundations to get right as a beginner.

• Numeric types: int (whole numbers), float (decimal numbers), bool (True or False)
• Strings: str (text)
• Collections - ways to group multiple values together:
  • list (ordered, can be changed)
  • tuple (ordered, cannot be changed)
  • set (only unique elements, no duplicates)
  • dict (pairs of keys and values)
• Type conversion - changing one type to another: int(), str(), etc.

Conditionals in Python

Conditionals let your program make decisions - doing one thing if something is true and something else if it is not.

• if, elif, else - basic decision making
• Nested conditions - checking multiple things at once for more complex logic
• Logical operators: and, or, not - combine or flip conditions
• Ternary operators - writing a simple if/else on a single line
• Best practices - how to write conditions that are easy to read

Loops in Python

Loops let you repeat a block of code automatically instead of writing it out many times.

• for loop - go through each item in a list or sequence one by one
• while loop - keep running as long as a condition is true
• Control statements that change how a loop behaves:
  • break - stop the loop immediately
  • continue - skip the current step and go to the next one
  • pass - do nothing (used as a placeholder)

Functions in Python

Functions let you group code into reusable blocks. Instead of writing the same code over and over, you write it once as a function and call it whenever you need it.

• Defining functions using def - how to create a function
• Parameters and return values - passing data in and getting data out
• Default arguments - making some parameters optional with a default value
• Variable arguments: *args, **kwargs - accepting any number of arguments
• Recursion - a function that calls itself to solve a problem step by step
• Lambda functions - tiny, one-line anonymous functions for simple tasks
• Command-line arguments - passing values to your script when you run it
• Higher-order functions: map(), filter(), reduce() - functions that work on other functions
• Scope and variable resolution - understanding where a variable can be accessed (LEGB rule)
• Docstrings - writing descriptions inside your functions so others know what they do

Comprehensions in Python

Comprehensions are a short, clean way to create lists, dictionaries, and sets without writing a full loop.

• List comprehension - build a list in one line
• Dictionary comprehension - build a dictionary in one line
• Set comprehension - build a set in one line
• Generator expressions - like list comprehensions but they only produce values one at a time, saving memory

Generators and Decorators in Python

These are slightly more advanced tools that help you write cleaner and more efficient code.

• Generators:
  • Use yield to produce values one at a time instead of all at once
  • Use much less memory than building a full list
• Generator expressions - a short way to write a generator
• Decorators:
  • Wrap a function to add extra behaviour without changing its code
  • Common real-world uses: logging, checking if a user is logged in (auth)

Object Oriented Programming in Python

OOP is a way of organising code by grouping related data and actions together into “objects.” This makes large programs much easier to manage and grow over time.

• Classes and objects - the main building blocks
• __init__ constructor - runs when a new object is created and sets it up
• Instance vs class variables - data that belongs to one object vs data shared by all objects
• Methods - functions that belong to an object and describe what it can do

Core Principles

• Encapsulation - keeping data and the code that uses it together, and hiding internal details
• Inheritance - one class can reuse code from another class
• Polymorphism - different classes can share the same method name but behave differently
• Abstraction - hiding the complicated parts and only showing what the user needs

Advanced Techniques

• Magic methods: __str__, __repr__, __len__ - special built-in methods that control how your object behaves
• Property decorators - a clean way to write getters and setters
• dataclasses - a shortcut for creating simple classes that mainly hold data
• Metaclasses - advanced control over how classes themselves are created

File and Exception Handling in Python

Almost every real program reads files or runs into errors. This section teaches you how to handle both safely.

• File handling operations:
  • Read and write files using context managers (the with statement)
  • Work with text files, binary files, and CSV files
  • Best practices for file input and output
• Exception handling:
  • try, except, finally blocks - catch and respond to errors without crashing
  • Common exception types and how they relate to each other
  • Custom exceptions - create your own error types for your specific program
  • How to recover from errors gracefully
  • Logging strategies - recording what happened so you can debug later

Common Python Libraries

These are the most useful libraries you will come across in everyday Python development. Some come with Python already, others need to be installed.

System and File Operations:

• os -> file system operations, reading environment variables
• sys -> interacting with the Python runtime, reading command-line arguments
• pathlib -> a modern, clean way to work with file paths
• shutil -> copying, moving, and deleting files and folders

Data Serialization (converting data to/from storable formats):

• json -> read and write JSON data
• csv -> read and write CSV files
• pickle -> save and load Python objects directly
• yaml -> read and write YAML format files

Database and Storage:

• sqlite3 -> a simple database that lives in a single file
• sqlalchemy -> a powerful library for working with databases using Python objects

Networking and APIs:

• requests -> the easiest way to make HTTP calls (call APIs, fetch web pages)
• urllib -> a built-in alternative for HTTP requests
• http.server -> spin up a basic HTTP server

Date and Time:

• datetime -> work with dates, times, and timezones
• time -> simple time utilities like pausing your script
• schedule -> run tasks automatically at set times

Utilities:

• itertools -> tools for working with loops and sequences more efficiently
• functools -> tools for functional programming patterns
• collections -> special container types like Counter, deque, and defaultdict

Networking in Python

This section covers how programs talk to each other over a network - from low-level sockets to high-level HTTP calls.

Fundamentals:

• IP addresses and ports - how devices and services are identified on a network
• Sockets - the basic building block of any network connection
• TCP vs UDP protocols - two different ways of sending data (reliable vs fast)
• How data is packaged and routed across a network

Socket Programming:

• Creating a server socket that waits for connections
• Handling client connections when they arrive
• Sending and receiving data in both directions
• Non-blocking I/O - handling connections without freezing the program

HTTP and REST APIs:

• The request/response cycle - how a client and server talk
• HTTP methods: GET, POST, PUT, DELETE - what each one is used for
• Headers and status codes - extra information about requests and responses
• Authentication and tokens - proving who you are to an API

Using the requests Library:

• Making GET and POST requests
• Adding query parameters and headers
• Sending JSON data in a request body
• Handling errors and retrying failed requests
• Using sessions for multiple requests to the same server

Multithreading, Multiprocessing, and GIL

This section explains how Python handles doing more than one thing at a time, and what the limits are.

Multithreading:

• Threading basics - running multiple tasks at the same time within one program
• Creating threads - starting and managing them
• Race conditions - what happens when two threads try to change the same data at once
• Locks and synchronization - tools to prevent race conditions
• Thread pools - a smarter way to manage many threads
• Daemon threads - background threads that stop when the main program ends

Multiprocessing:

• Process vs thread - the key differences and when to use each
• Process creation - running code in a completely separate process for true parallelism
• Sharing data between processes
• Inter-process communication (IPC) - how separate processes send messages to each other
• When multiprocessing is a better choice than threading

Global Interpreter Lock (GIL):

• What the GIL is - a lock inside CPython that only lets one thread run Python code at a time
• How it affects concurrency - threads cannot truly run in parallel for CPU-heavy tasks
• The difference between CPU-bound tasks (affected by GIL) and I/O-bound tasks (not much affected)

graph TD Start["Python Process"] -->|Main Thread| GIL["Global<br/>Interpreter<br/>Lock<br/>GIL"] T1["Thread 1"] T2["Thread 2"] T3["Thread 3"] T1 -->|Request| GIL T2 -->|Request| GIL T3 -->|Request| GIL GIL -->|Executes| One["Only ONE Thread<br/>At a Time"] One -->|Result| End["⚠ CPU-bound<br/>Tasks Slow"]

Asyncio in Python

Asyncio is Python’s built-in way of handling many tasks at once without using threads. It works especially well when your program spends a lot of time waiting - like waiting for an API response or a file to load.

• Coroutines:
  • async and await keywords - how you write async code in Python
  • How to define and run an async function
  • The coroutine protocol - how Python knows a function is async
• Event loop:
  • The engine that drives async code - it keeps checking which tasks are ready to run
  • Task scheduling - deciding what runs next
  • Non-blocking I/O - waiting for something without freezing everything else
• Async tasks:
  • Creating and managing tasks that run at the same time
  • Task groups and running multiple tasks together
  • Cancelling tasks and setting timeouts
• Practical patterns:
  • I/O-bound operations like network calls and file reads
  • CPU-bound tasks should use multiprocessing instead of asyncio
  • Async context managers - using with in async code
  • Handling errors in async code

Testing in Python

Testing means writing extra code that checks your main code works correctly. It might feel like extra work at first, but it saves you a lot of time debugging later.

Assertion Testing:

• assert statements - the simplest way to check that something is true
• Common assertion patterns for testing conditions

unittest Framework:

• Test cases and test suites - how to organise your tests
• Setup and teardown methods - run code before and after each test
• Test discovery - automatically finding all your test files
• Assertions and comparisons - the built-in tools for checking results
• Mocking and patching - replacing real dependencies with fake ones during tests

pytest Framework (Recommended):

• Writing simple test functions - no need for a class
• Fixtures - reusable setup code shared between tests
• Test discovery - automatically finding tests
• Parametrized testing - running the same test with many different inputs
• Markers and test categories - grouping and filtering tests
• Command-line options for running specific tests
• Works well with CI/CD tools like GitHub Actions

Best Practices:

• Test coverage - measuring how much of your code is tested
• TDD (Test-Driven Development) - writing tests before you write the code
• Mocking external dependencies - replacing APIs, databases, etc. with fake versions in tests
• Integration vs unit tests - knowing the difference and when to use each

These are the core topics and tools you need to get started with Python. Work through them one by one and you will build the skills to create everything from small automation scripts to full web applications. Happy coding!