Python Course

Learn Python step by step in your browser — a free online course with 68 articles and 250 hands-on exercises. Covers print, variables, data types, if / for / functions / exception handling, classes and inheritance, special methods and OOP, organizing multiple files with modules and packages, and the standard library (datetime / os / re / json / asyncio). Build production-ready Python skills as fast as possible — even as a beginner. No setup required.

0/73テキスト終了（0%）

Python Basics

What You'll Learn in This Python Course — Production-Ready, Fast
An overview of the full Python course curriculum. Walk through what to learn and in what order to build production-ready Python skills as fast as possible — covering syntax, OOP, and the standard library — plus what's still essential in the AI era: solid basics and error handling.
Printing and Comments
Your first step in Python. A beginner-friendly walkthrough of printing to the screen with print(), writing comments using # and """, and embedding values with f-strings.
Variables and Data Types
A beginner-friendly guide to Python variables and data types — using int and str, dynamic typing and reassignment, naming rules and reserved words, the constants convention, and converting between int and str.
Booleans and Building Conditions
A beginner-friendly guide to Python's boolean type — the two values True and False, how comparison operators produce booleans, the and / or / not logical operators, and how to avoid the classic = vs == mix-up.
Numbers and Floating Point
A deep dive into Python's numeric types — int vs float, the ** power operator and compound assignments like +=, the difference between / and //, float precision pitfalls, and converting with int() and float().
How to Use Python Strings (str)
A thorough guide to Python's string type (str). Learn when to use single, double, and triple quotes; how indexing and slicing pull out characters; transformation methods like upper/lower/replace/strip; and inspection methods like count/find/startswith/isdigit — all with runnable practice exercises.
Converting Between Numbers and Strings
A clear guide to converting between numbers and strings in Python. From the basics of str() to turn numbers into strings, and int() / float() to turn strings into numbers, to avoiding TypeError / ValueError and how to cast a decimal string to an integer — all with runnable exercises.
How to Use Python Lists (list)
A thorough guide to Python's list type. Learn declarations and indexing, slicing to pull out ranges, add/remove methods like append/extend/insert/remove/pop, and sort/reverse/count/index — all with runnable exercises.
How to Use Python Dictionaries (dict)
A thorough guide to Python's dict type. Declaring key-value pairs, how [] differs from .get() when retrieving, adding/updating/deleting entries, listing data with keys / values / items, and checking key existence with in — all with runnable practice exercises.
How to Use Python Tuples (tuple)
A guide to Python's tuple type, focused on how it differs from a list. Covers parentheses-based declarations, what immutability really means, the count / index methods, unpacking several values in one line, and why tuples can be used as dict keys — all with runnable, browser-based exercises.
How to Use Python Sets (set)
A guide to Python's set type. Covers the two defining rules (no duplicates, no order), element operations with add / remove / discard / pop / clear, set operations (union / intersection / difference / symmetric_difference), and the real-world patterns of deduplication and fast membership checks — with exercises you can run in the browser.
Mutable and Immutable Types
A careful walkthrough of mutable and immutable types in Python. The y = x trap that makes two variables share the same box, why it becomes a bug, and how copy() gives you an independent version — all with runnable browser exercises.
Python Types Roundup — Why Types Matter and the Door to Classes
A roundup of the data types covered in Python Basics. Revisit what a "type" really is, review which type fits which job with a handy table, and take your first step into OOP — defining your own type with class — all with diagrams.
Python Basics Wrap-Up Problems — Put What You Learned into Code
Three exercises that pull together what you learned in Python Basics — string handling, type conversion, set operations, and mutability. Write code, run it, and review the whole chapter at once.

Python Syntax

if / elif / else and Advanced Branching
A deeper look at Python's conditional branching — multi-way logic with elif / else, truthiness covering empty strings and 0, the ternary operator, the difference between is and ==, type checks with isinstance, and element checks with in / not in — all with runnable practice exercises.
Bulk Checks with all() and any()
A from-the-ground-up guide to all() / any() for judging the elements of a list or tuple in bulk. Learn all() for "is everything True?", any() for "is at least one True?", their typical use cases, and how to combine them with for — all with runnable practice exercises.
List Comprehensions and Dict / Set / Generator Expressions — Build Collections in One Line
A practical guide to Python comprehensions: list, dict, set, and generator expressions, plus filtering with if. Includes runnable exercises.
for Loops with range / enumerate / zip
A systematic walkthrough of Python's for statement. Looping over lists and dicts one element at a time, using range() for fixed-count loops, indexed loops with enumerate(), parallel iteration over multiple lists with zip(), and loop control with break / continue — all with runnable practice exercises.
while Loops and Avoiding Infinite Loops
A from-the-ground-up guide to Python's while loop. Repeating while a condition holds, building termination conditions to avoid infinite loops, forced exits with break and skips with continue, and choosing between for and while — all with runnable practice exercises.
The Walrus Operator := for Assigning and Testing in One Line
A from-the-ground-up guide to Python 3.8's walrus operator :=. Covers the basic syntax for assigning and testing in a single line, reusing the tested value inside if, combining the pop-and-test pattern in while, the paren-forgetting pitfall that assigns the comparison result, and when to use it or avoid it — all with runnable practice exercises.
Catching Exceptions with try / except
A from-the-ground-up guide to Python's exception handling try / except. Covers syntax vs. runtime errors, the basic try / except shape, capturing the exception object with as e, catching multiple exceptions separately, the umbrella Exception catch, and cleanup with finally — all with runnable practice exercises.
Raising Exceptions with raise / Custom Exception Classes
A guide to throwing exceptions yourself in Python with raise. Covers the basics of raise ValueError("message"), the if + raise validation pattern, and defining a custom exception with class MyError(Exception): to catch it pinpoint-precise with try / except — all with runnable practice exercises.
Defining Functions with def — Arguments, Return Values, Default and Keyword Arguments
A from-the-ground-up guide to Python's function definition def. Covers the basics of def and return, caller-side arguments and return values, default arguments, and keyword arguments — all with runnable practice exercises.
Variable-Length Arguments *args / **kwargs and Multiple Return Values
Learn Python's *args / **kwargs and multiple return values in your browser. Diagrams cover positional/keyword arguments, unpacking with *list / **dict, and tuple returns. Includes runnable exercises.
Function Arguments and Object References — Mutables Get Modified Inside Functions
Learn how Python function arguments behave with mutable vs immutable types. Walk through why list/dict mutations leak to the caller, the .copy() pattern, and the mutable default argument trap — with runnable exercises.
Inner Functions and Closures — Mastering Scope with global and nonlocal
Walk through Python scope, inner functions, and closures: how globals and locals split, when to reach for global and nonlocal, and how to return a function that remembers outer values. Includes runnable exercises.
Generator Functions with yield — Producing Values One at a Time
Walk through Python generator functions: yield to return values one at a time, pulling them with next() and for, the memory gap between a list and a generator, and chaining with yield from. Includes runnable exercises.
Higher-Order Functions — Treating Functions as Arguments and Return Values
Walk through Python higher-order functions in the browser: assigning functions to variables, passing them as callbacks to swap behavior, branching on multiple callbacks, and returning a closure that remembers its setting. Includes runnable exercises.
Lambda Expressions — Writing Anonymous Functions in One Line
Learn Python's lambda expressions from the ground up while running code in your browser. Cover the basic lambda args: expression form, multiple arguments, conditional expressions, default arguments, pairing with higher-order functions like sorted's key, and when to fall back to def — all with runnable exercises.
Decorators — Adding Behavior to Functions with @
Walk through Python decorators in your browser, from the basics. Covers the @decorator syntax, the standard def → return inner shape, passing any arguments through with *args / **kwargs, decorators with arguments like @repeat(3), and real-world uses in frameworks like Flask and pytest. Includes runnable exercises.
map() — Apply a Function to Every Element of a List at Once
A runnable, browser-based walkthrough of Python's map() function from the ground up. Covers the map(function, iterable) basics, materializing results with list(), pairing with lambdas and built-ins like int, passing multiple iterables at once, and choosing between map() and list comprehensions — with hands-on exercises throughout.
Python Syntax Wrap-Up — Choosing Between Control Flow and Functions
A roundup of Python syntax (control flow and functions). Cross-cuts conditional branching, loops, exception handling, and function applications into one clear map.
Python Syntax Wrap-Up Problems — Combine Control Flow, Functions, and Exceptions
Three exercises that pull together what you learned in Python Syntax — control flow, functions, list comprehensions, exception handling, and decorators — into review problems.

Python Object-Oriented Programming

Classes and Instances — Defining Your Own Type
An entry point into Python's OOP: define a class with class, create instances from it, and learn the role of self and how __init__ sets attributes. Includes runnable practice exercises.
The Constructor __init__ and the Destructor __del__
A practical guide to Python's constructor __init__ and destructor __del__. Covers enforcing required attributes at instance creation, defining default values, and the cleanup method called on del and program exit. Includes runnable practice exercises.
Class Variables vs Instance Variables — Where Values Actually Live
A careful walkthrough of the two kinds of variables in Python classes — **class variables** shared by everyone, and **instance variables** owned by each instance. See exactly what self.x = ... does and verify references with id(). Includes runnable practice exercises.
Instance, Class, and Static Methods — The Three Method Types
A guide to the three kinds of methods you can define in a Python class — **instance methods** that take self, **class methods** with @classmethod and cls, and **static methods** that take no special first argument. Practical patterns like validation and factories, with runnable exercises.
Special Methods — Teaching Your Class How + and print Behave
A walkthrough of Python's special (dunder) methods. Define + with __add__, separate user-facing and developer-facing strings with __str__ / __repr__, redefine == meaningfully with __eq__, plus typical uses of __call__, __len__, and __bool__. Includes runnable practice exercises.
Class Inheritance — Reusing Features from an Existing Class
A walkthrough of Python class inheritance. Inherit attributes and methods with class Child(Parent):, override methods in subclasses, call the parent's logic with super().method(), and grow attributes by overriding __init__ — the standard pattern. Includes runnable practice exercises.
Multiple Inheritance and MRO — Inheriting from More Than One Parent
A walkthrough of Python multiple inheritance. Combine parents with class Child(A, B):, see how the **method resolution order (MRO)** picks among same-named methods, check the order with __mro__, walk through C3 linearization for diamond inheritance, and target a specific parent by class name. Includes runnable practice exercises.
Polymorphism — Same Method Name, Different Behavior per Type
A walkthrough of Python polymorphism. Override a parent's method per subclass so callers can use one name regardless of type, process mixed types in a single loop, replace if type(...) branches with cleaner OOP, and learn Python's signature **duck typing**. Includes runnable practice exercises.
Private Variables and Encapsulation — Safe Access via getter / setter
A walkthrough of Python's private variables and encapsulation. The _x convention vs __x name mangling, safe access via get_xxx / set_xxx with validation in setters, and the Pythonic @property / @xxx.setter style with computed properties. Includes runnable practice exercises.
File I/O — Safely Read and Write with with open()
A walkthrough of Python file I/O. with open() auto-close, the difference between read / readlines / readline, the w / a modes, and the read-process-write pattern that saves results to a separate file. Includes runnable practice exercises.
with Statement and Context Managers — Safe Open/Close with __enter__ / __exit__
A walkthrough of Python's with statement and context managers. The __enter__ / __exit__ pair that auto-opens and auto-closes resources, the value flow through the as clause, exception handling via exc_type / exc_val / traceback, and the comparison with try / finally. Includes runnable practice exercises.
Type Hints — Leave Your Intent in the Code with : int and -> str
A walkthrough of Python type hints (type hints). The def f(x: int) -> str: function signature, when to add a variable annotation like name: str = "Alice" and when not to, how IDEs and mypy use them for static checking, and the fact that types are not enforced at runtime. Includes runnable practice exercises.
Python OOP Summary — Bundling Data and Behavior into Classes
A wrap-up of Python OOP. Covers class fundamentals, inheritance and polymorphism, special (dunder) methods, with statements, encapsulation, and type hints across the series, with cross-links to every article.
Python OOP Wrap-Up Problems — Put What You Learned into Code
Four exercises that pull together what you learned in Python OOP — class definitions with special methods, inheritance, encapsulation, and polymorphism. Write code, run it, and review the whole chapter at once.

Python Intermediate

Modules and Packages — Importing from Other Files
Learn the differences between Python modules, packages, and libraries plus how the import statement pulls functions in from other files. Covers standard vs. third-party libraries, importing your own modules, what runs at import time, the __name__ == "__main__" check, and combining several modules — with runnable practice exercises.
__init__.py and Relative Imports — Bundling Files into a Package
Learn the role of __init__.py for building Python packages and when to reach for absolute vs. relative imports. Covers bundling several modules under one folder, narrowing the public API with from-package imports, mixing absolute and relative imports correctly, and a real-project folder layout — with runnable practice exercises.
Standard Library Categories — When to Use What
Get a bird's-eye view of Python's standard library across 7 categories. Date handling, numeric work, data I/O, concurrency — figure out what to import for each situation.
sys and argparse — Runtime Info and Argument Parsing
Learn the Python sys and argparse modules from the ground up. From reading runtime info with sys.path / sys.argv / sys.exit to building structured argument parsers with argparse — all hands-on.
os and pathlib — File Paths and Directory Operations
Learn Python's os.path and pathlib modules from the basics. Build OS-agnostic paths, list and recursively walk directories, and break paths into pieces with Path objects — all hands-on.
shutil and tempfile — Bulk File Ops and Temp Files
Learn Python's shutil and tempfile from the ground up. Bulk file operations with shutil.copy / shutil.move / shutil.rmtree, plus how to safely use temporary files via tempfile.NamedTemporaryFile — all hands-on.
datetime and time — Working with Dates, Times, and Elapsed Time
Learn Python's datetime / time / calendar modules from the ground up. Covers date arithmetic with date / datetime / timedelta, string conversion via strftime / strptime, and elapsed-time measurement with time.perf_counter — all hands-on.
math and statistics — Single-Value Math and Data Aggregation
Learn Python's math and statistics modules from the ground up. Covers single-value math with math.sqrt / pi / floor / ceil / log, data aggregation with statistics.mean / median / mode / stdev, and how the two modules split responsibilities — with runnable practice exercises.
decimal and fractions — Precise Arithmetic Without Float Errors
Learn Python's decimal and fractions modules from the ground up. Covers the 0.1 + 0.2 != 0.3 problem with float, exact monetary calculation with Decimal (and why you build Decimals from strings), arithmetic with auto-reducing Fraction, and choosing among the three numeric types — with runnable practice exercises.
random and secrets — Choosing the Right Random Numbers
Learn Python's random and secrets modules from the ground up. Covers reproducible pseudorandom sequences with random.choice / randint / shuffle / sample plus seed, cryptographically safe tokens with secrets.token_hex / token_urlsafe, and when to use one vs. the other — with runnable practice exercises.
Regular Expressions re — Pattern Search and Replacement
Learn Python's re module from the ground up. Covers when to reach for re.match / re.search / re.findall, combining metacharacters \d / \w / \s / * / + / ?, capturing groups with ( ), substitution with re.sub, and reusing patterns with re.compile — with runnable practice exercises.
string and textwrap — Character Constants, Templates, and Formatting
Learn Python's string and textwrap modules from the ground up. Covers character constants like string.ascii_letters / digits, $name-style template substitution with string.Template, removing indentation from triple-quoted strings with textwrap.dedent, and width-wrapping with fill — with runnable practice exercises.
pprint — Reading Nested dicts and lists Comfortably
Learn Python's pprint module from the ground up. Covers how pprint.pp keeps nested dict / list structure readable where print fails, stringifying with pformat, the width / indent / sort_dicts options, and using it in everyday debugging — with runnable practice exercises.
json and csv — Reading and Writing Structured Data
Learn Python's json and csv modules from the ground up. Covers converting between Python objects and JSON strings with json.dumps / loads, formatting with indent and ensure_ascii, position-based reading and writing with csv.writer / reader, and column-name-based dict I/O with DictWriter / DictReader — with runnable practice exercises.
pickle and base64 — Serializing Objects and Encoding Binary as Text
Learn Python's pickle and base64 modules from the ground up. Covers serializing Python objects with pickle.dumps / loads, converting binary data to and from text with base64.b64encode / b64decode, when to choose the urlsafe variant, and pickle's security caveats — with runnable practice exercises.
hashlib — Compute Hash Values for Data
Learn Python's hashlib module from the ground up. Covers fixed-length hash values via SHA-256, the three properties (deterministic, avalanche, one-way), implementing tamper detection and integrity checks, and why password storage shouldn't rely on hashlib alone — with runnable practice exercises.
collections — Counter / defaultdict / deque / namedtuple
Learn Python's collections module from the ground up. Covers tallying with Counter and most_common, missing-key handling with defaultdict, O(1) operations on both ends and ring buffers via deque + maxlen, and attribute access plus dict conversion with namedtuple — with runnable practice exercises.
itertools and functools — Iteration and Function Composition Toolkits
Learn Python's itertools and functools modules from the ground up. Covers iteration with combinations / product / chain / accumulate, locking arguments with partial, and speeding up calls with @lru_cache memoization — with runnable practice exercises.
enum and dataclasses — Named Constants and Data Classes
Learn Python's enum and dataclasses modules from the ground up. Covers named constants with Enum and IntEnum / auto, auto-generating __init__ / __eq__ / __repr__ via @dataclass, and choosing between field and frozen=True — with runnable practice exercises.
contextlib — Resource Management and Custom with
Learn Python's contextlib module from the ground up. Covers writing your own with statement easily via @contextmanager and swallowing specific exceptions with suppress — with runnable practice exercises.
logging — Record instead of print
Learn Python's logging module from the ground up. Covers level routing and basicConfig setup, unified formatting via Formatter, file output via FileHandler, yaml + dictConfig configuration, and rotation via RotatingFileHandler — with runnable practice exercises.
async / await Basics — Make Programs Faster by Using Wait Time
Learn Python's async and await from the ground up. Coroutines, the event loop, asyncio.sleep, asyncio.run, and top-level await — illustrated with hands-on exercises.
asyncio Tasks — Concurrent Execution with gather, Task, and Queue
Learn Python asyncio for concurrent code: gather for parallel runs, create_task for fire-and-await-later, wait_for for timeouts, and Queue for producer / consumer.
threading and multiprocessing — Threads, Processes, and the GIL
An illustrated walkthrough of Python's threading, multiprocessing, and subprocess modules. Covers threads vs. processes, the GIL constraint, using ThreadPoolExecutor and Pool, deciding among I/O-bound, CPU-bound, and external-command workloads, and the comparison with vectorized libraries like NumPy — with diagrams to organize the concepts.
Python Standard Library Wrap-Up — 17 Modules Across 7 Categories
An illustrated wrap-up of the Python standard library series. 17 modules organized into 7 categories, what external libraries are, the standard → external transition (urllib → requests, csv → pandas, etc.), and go-to third-party libraries by use case (FastAPI / pandas / scikit-learn / requests / pytest).
Wrapping Up the Python Course — Nice Work Getting Here
An article for those who made it all the way through the Python course's four chapters.