Python

Hard

Skills

Core

Language

Fundamentals

SKILLS

Built

data

types

int

float

complex

str

bytes

bool

None

—

conversions

and

coercion

rules

Scope

and

the

LEGB

rule

Local

enclosing

global

built

resolution

;

global

and

nonlocal

declarations

Operators

and

truthiness

Arithmetic

chained

comparisons

bitwise

operations

walrus

operator

(:=)

Comprehensions

List

dict

set

and

generator

expressions

with

filters

and

nesting

Indexing

and

slicing

Negative

indices

step

slicing

slice

objects

slice

assignment

Unpacking

and

starred

expressions

Tuple

unpacking

extended

iterable

unpacking

swap

and

rest

patterns

String

handling

and

formatting

strings

str

format

, %-

formatting

escape

sequences

encode

decode

Control

flow

and

pattern

matching

elif

else

for

else

while

loops

break

continue

match

case

structural

matching

Data

Structures

and

Algorithms

SKILLS

Built

containers

list

tuple

dict

set

frozenset

—

time

complexity

core

operations

Collections

module

deque

defaultdict

Counter

OrderedDict

namedtuple

ChainMap

Sequence

and

mapping

abstractions

Iterable

Iterator

Sequence

Mapping

MutableMapping

protocols

Sorting

and

searching

sorted

with

key

functions

bisect

stable

sorts

custom

ordering

rules

Recursion

and

memoization

Base

cases

recursion

depth

limits

functools

lru

cache

and

cache

Complexity

analysis

(

Big

)

Time

and

space

complexity

amortized

cost

structure

selection

trade

offs

Graph

and

tree

traversal

BFS

DFS

heap

operations

via

heapq

topological

sort

binary

trees

Dynamic

programming

and

greedy

methods

Tabulation

memoized

recursion

optimal

substructure

greedy

proofs

Object

Oriented

and

Functional

Python

SKILLS

Classes

and

instances

init

__,

self

instance

class

static

methods

attribute

resolution

Inheritance

and

MRO

Multiple

inheritance

super

()

usage

linearization

mixin

design

Dunder

methods

repr

__, __

str

__, __

hash

__, __

len

__, __

iter

__,

enter

__/__

exit

Properties

and

descriptors

property

with

setters

and

deleters

data

non

data

descriptors

Dataclasses

dataclass

field

(),

frozen

slots

order

, __

post

init

validation

Abstract

base

classes

and

protocols

abc

ABC

, @

abstractmethod

duck

typing

via

typing

Protocol

Metaclasses

and

class

creation

type

(), __

new

__, __

init

subclass

__,

class

registration

patterns

Functional

tooling

map

filter

reduce

operator

module

functools

partial

itertools

pipelines

1 / 6

Standard

Library

SKILLS

and

pathlib

Filesystem

paths

environment

variables

directory

walking

file

metadata

sys

module

argv

stdin

stdout

stderr

module

path

runtime

limit

configuration

datetime

and

zoneinfo

Aware

naive

datetimes

parsing

ISO

8601,

time

zone

conversion

Serialization

formats

json

csv

configparser

tomllib

base

encoding

Regular

expressions

(

)

Patterns

capture

groups

lookarounds

compiled

pattern

reuse

itertools

and

functools

Infinite

iterators

combinations

permutations

caching

functools

wraps

Numeric

utilities

math

statistics

random

with

seeding

decimal

for

precise

arithmetic

subprocess

and

shutil

Running

external

commands

capturing

output

file

copy

move

and

archiving

argparse

logging

contextlib

CLI

parsing

log

levels

and

handlers

context

managers

with

contextlib

Web

Development

and

APIs

SKILLS

Web

frameworks

FastAPI

Flask

Django

—

routing

request

handling

templating

ORM

layers

REST

API

design

Resource

modeling

HTTP

verbs

status

codes

versioning

pagination

Request

validation

with

Pydantic

Models

field

validators

settings

management

serialization

schemas

Authentication

and

authorization

OAuth

2.0,

JWT

session

handling

password

hashing

with

bcrypt

argon

Middleware

and

dependency

injection

WSGI

and

ASGI

lifecycles

FastAPI

Depends

request

scoped

resources

Templating

engines

Jinja

syntax

template

inheritance

autoescaping

and

safe

rendering

API

documentation

OpenAPI

Swagger

schemas

generated

from

typed

endpoints

and

docstrings

Real

time

channels

WebSockets

server

sent

events

connection

lifecycle

and

reconnect

logic

Async

Concurrency

and

Parallelism

SKILLS

asyncio

fundamentals

Event

loop

coroutines

tasks

asyncio

gather

TaskGroup

timeouts

async

await

syntax

Awaitable

protocol

async

iterators

async

context

managers

Threading

primitives

threading

Lock

RLock

Semaphore

Condition

thread

safe

Queue

The

GIL

and

its

consequences

What

the

GIL

blocks

and

the

patterns

that

work

around

Multiprocessing

Process

pools

shared

memory

pickling

constraints

worker

startup

cost

concurrent

futures

ThreadPoolExecutor

ProcessPoolExecutor

futures

completed

Backpressure

and

rate

limiting

Bounded

queues

semaphores

retries

with

exponential

backoff

and

jitter

Race

conditions

and

deadlocks

Diagnosis

critical

sections

atomic

operations

lock

ordering

discipline

2 / 6

Data

Analysis

and

Scientific

Computing

SKILLS

NumPy

ndarrays

broadcasting

vectorization

dtypes

universal

functions

pandas

Series

and

DataFrame

loc

iloc

indexing

groupby

merge

pivot

resample

Data

cleaning

Missing

value

strategies

type

coercion

deduplication

outlier

handling

Visualization

Matplotlib

figures

and

axes

Seaborn

statistical

plots

chart

styling

Notebook

workflows

Jupyter

cells

magics

execution

order

reproducibility

practices

Large

data

tooling

Polars

lazy

frames

DuckDB

columnar

queries

larger

than

memory

processing

Time

series

handling

Datetime

indexes

resampling

rolling

windows

lag

features

seasonality

Statistical

analysis

Descriptive

statistics

hypothesis

testing

correlation

SciPy

stats

Machine

Learning

and

SKILLS

scikit

learn

Pipelines

transformers

estimators

cross

validation

grid

and

random

Feature

engineering

Encoding

scaling

imputation

text

and

date

feature

construction

Model

evaluation

Precision

and

recall

ROC

AUC

confusion

matrices

leakage

avoidance

Gradient

boosting

XGBoost

LightGBM

CatBoost

early

stopping

hyperparameter

tuning

Deep

learning

PyTorch

TensorFlow

tensors

autograd

training

and

validation

loops

NLP

and

LLM

tooling

Tokenization

embeddings

transformer

models

vector

stores

retrieval

Model

deployment

joblib

and

ONNX

serialization

batch

real

time

inference

drift

checks

MLOps

fundamentals

Experiment

tracking

with

MLflow

artifact

versioning

reproducible

training

Testing

and

Code

Quality

SKILLS

pytest

Fixtures

parametrize

markers

conftest

organization

plugin

ecosystem

unittest

TestCase

classes

setUp

and

tearDown

assertions

test

discovery

Mocking

and

patching

unittest

mock

MagicMock

patch

targets

injectable

dependency

seams

Coverage

measurement

coverage

branch

coverage

meaningful

thresholds

untested

path

review

Test

levels

Unit

integration

end

property

based

testing

with

Hypothesis

TDD

workflow

Red

green

refactor

cycle

test

design

fast

local

feedback

loops

Linting

and

formatting

ruff

flake

black

isort

pylint

—

configuration

and

auto

fix

rules

Code

review

practices

Naming

readability

docstring

conventions

(

Google

NumPy

reST

styles

)

3 / 6

Packaging

Tooling

and

Environments

SKILLS

Virtual

environments

venv

virtualenv

conda

—

isolation

activation

interpreter

pinning

Dependency

management

pip

requirements

files

pip

tools

Poetry

lock

file

discipline

Packaging

and

distribution

pyproject

toml

setuptools

build

wheels

sdists

PyPI

publishing

Semantic

versioning

Version

pinning

constraint

ranges

resolving

dependency

conflicts

Project

layout

src

layout

package

module

design

entry

points

console

scripts

Pre

commit

hooks

Automated

formatting

linting

and

secret

scanning

before

commit

Task

runners

Makefiles

invoke

tox

and

nox

matrices

for

environment

parity

Documentation

tooling

MkDocs

Sphinx

autodoc

rendering

docstrings

into

published

docs

Databases

ORMs

and

Data

Stores

SKILLS

SQL

fundamentals

SELECT

JOIN

GROUP

subqueries

window

functions

index

awareness

Relational

database

drivers

SQLite

PostgreSQL

MySQL

—

connections

cursors

parameterized

queries

ORMs

SQLAlchemy

Core

and

ORM

Django

ORM

session

lifecycle

avoiding

Schema

migrations

Alembic

Django

migrations

versioned

schema

changes

and

rollbacks

NoSQL

and

caching

stores

MongoDB

via

PyMongo

Redis

caching

document

and

key

value

modeling

Transactions

and

pooling

ACID

guarantees

isolation

levels

commit

and

rollback

connection

pools

Query

optimization

EXPLAIN

plans

indexing

strategy

batching

versus

per

row

writes

ETL

and

data

pipelines

Extraction

transformation

idempotent

loads

scheduling

with

Airflow

DevOps

Cloud

and

Deployment

SKILLS

Containerization

Dockerfiles

multi

stage

builds

slim

base

images

dockerignore

pipelines

GitHub

Actions

GitLab

matrix

builds

automated

test

and

deploy

gates

Cloud

platforms

AWS

with

boto

GCP

and

Azure

SDKs

—

compute

storage

managed

services

Infrastructure

code

Terraform

Pulumi

declarative

environment

and

resource

configuration

Serverless

functions

AWS

Lambda

handlers

cold

start

behavior

deployment

package

limits

Application

servers

Gunicorn

and

Uvicorn

workers

ASGI

WSGI

setup

Nginx

reverse

proxy

Observability

Structured

logging

Prometheus

metrics

distributed

tracing

error

tracking

Secrets

management

Environment

variables

HashiCorp

Vault

AWS

Secrets

Manager

key

rotation

4 / 6

Performance

Profiling

and

Optimization

SKILLS

Profiling

cProfile

line

profiler

spy

memory

profiler

flame

graph

reading

Benchmarking

timeit

pytest

benchmark

warm

runs

statistical

significance

Caching

strategies

process

caches

Redis

layers

HTTP

caching

headers

cache

invalidation

Memory

optimization

slots

__,

generators

over

lists

object

lifetime

leak

detection

Native

acceleration

Cython

cffi

Numba

JIT

accelerated

library

selection

Lazy

evaluation

Generators

itertools

pipelines

streaming

large

files

without

them

optimization

Buffered

reads

chunked

processing

batched

database

writes

Native

interoperability

Calling

and

Rust

extensions

FFI

boundary

overhead

considerations

Type

System

and

Static

Analysis

SKILLS

Type

hints

Function

and

collection

annotations

Optional

Union

Callable

return

types

typing

module

Generic

TypeVar

Protocol

TypedDict

Literal

overload

decorators

Static

checkers

mypy

and

pyright

configuration

strictness

levels

incremental

adoption

Runtime

validation

Pydantic

models

typeguard

assert

based

internal

contracts

Structured

records

TypedDict

and

dataclass

typing

immutability

semantics

field

defaults

Generics

and

variance

Covariance

and

contravariance

rules

applied

real

container

designs

Gradual

typing

Typing

legacy

codebases

Any

discipline

ratcheting

strictness

over

time

API

contracts

types

Types

executable

documentation

stable

public

interfaces

across

releases

Automation

Scripting

and

CLI

SKILLS

System

and

file

automation

Batch

renaming

log

parsing

scheduled

maintenance

jobs

dry

run

modes

Web

scraping

requests

httpx

BeautifulSoup

lxml

rate

limiting

robots

txt

etiquette

Browser

automation

Playwright

Selenium

headless

flows

explicit

waits

and

robust

selectors

CLI

development

argparse

Click

Typer

subcommands

exit

codes

helpful

error

output

Task

scheduling

cron

APScheduler

Airflow

DAGs

idempotent

and

resumable

jobs

Messaging

automation

smtplib

transactional

APIs

Slack

and

Teams

webhook

notifications

Office

document

automation

openpyxl

pandas

ExcelWriter

python

docx

PDF

and

report

generation

Third

party

API

integration

REST

and

GraphQL

clients

pagination

retries

timeouts

webhook

verification

5 / 6

Security

and

Secure

Coding

SKILLS

Input

validation

and

sanitization

Untrusted

input

handling

path

traversal

prevention

injection

defense

SQL

injection

defense

Parameterized

queries

ORM

escaping

least

privilege

database

accounts

Cryptography

hashlib

hmac

secrets

module

Fernet

symmetric

encryption

TLS

basics

Dependency

security

pip

audit

safety

Dependabot

alerts

vulnerability

triage

and

upgrades

Secure

configuration

secrets

source

control

environment

separation

least

privilege

Error

handling

hygiene

Explicit

exception

types

safe

user

facing

messages

sensitive

data

logs

Deserialization

safety

Avoiding

pickle

untrusted

data

safe

parsers

schema

validation

OWASP

awareness

Python

Applying

the

top

web

risks

Python

services

frameworks

and

APIs

Version

Control

and

Collaboration

SKILLS

Git

fundamentals

clone

branch

commit

merge

rebase

stash

Python Hard Skills

Prompt to Clone This Python Hard Skills

Apply this example's core structure, strategic pacing, and structural hierarchy directly to your own topic.

What are you generating today?