Hasty Briefsbeta

All tags

python

21 stories total

Bilingual

Logic for Programmers by Hillel Wayne
2 months ago
- all(l) is equivalent to the AND of all elements in the list.
- The property all(xs . ys) == all(xs) && all(ys) holds for any two lists.
- For an empty list, all([]) must be True to preserve the property, and it is the identity element for &&.
- Similarly, sum of empty list is 0 and any([]) is False.
Terrible Horrible No Good Very Bad Python
2 months ago
- The code `return return False` returns `False` after the outer `return` is processed from a `finally` block.
- Normally, `os._exit` exits the process without cleanup, but omitting the argument raises a `TypeError`.
- The `finally` block silently swallows the `TypeError` due to the `return` statement, which is a common misuse.
- Python developers plan to issue a `SyntaxWarning` for `return` in `finally` blocks in a future release.
- Dynamic scoping in Python allows `import os` to work even if it appears after the function definition.
- `sys.exit` raises `SystemExit`, which can be caught by `finally`, unlike `os._exit` which directly terminates without running handlers.
Beej's Bit Bucket
2 months ago
- Design patterns are reusable solutions to common software design problems, not algorithms but structures for data flow.
- The Observer Pattern allows an observable object to notify multiple observer objects when an event occurs.
- Common uses include asynchronous events (e.g., network data receipt) and GUI event handling (e.g., button clicks).
- Observers register callbacks; the observable notifies all registered observers when the event happens.
- Benefits: decoupling, easy addition of new observers without modifying existing code, and support for multiple listeners.
- Example: a GoatDetector class that notifies observers when the word 'goat' appears in input.
- A more advanced version uses a dictionary to map events to lists of observers, supporting multiple event types.
- The Observer Pattern is a concept, not a rigid implementation; it can be adapted to fit various scenarios.
Beej's Bit Bucket
2 months ago
- Virtual environments isolate Python packages, preventing system pollution and conflicts.
- Create a virtual environment with `python -m venv <env-name>`; activate by sourcing `bin/activate`.
- While active, install packages using `pip install`; they are confined to the environment.
- Deactivate with `deactivate` or by exiting the shell; delete the environment directory to remove it.
- Run scripts directly using the venv's Python path (e.g., `/path/to/venv/bin/python script.py`) without activation.
- Third-party tools like `uv` can streamline virtual environment management.
Object Oriented Python
2 months ago
- Python's flexibility includes dynamic typing, array splicing, list concatenation with '+', and using docstrings as documentation.
- Python forbids compile-time type declarations, global variable assignment in the same statement, and bad indentation.
- Python objects use built-in functions like len() that call special methods (__len__), enabling uniform handling of different object types.
- Inheritance is achieved by passing the superclass to the class definition; methods require explicit 'self' parameter for instance attribute access.
- Constructors involve __new__ and __init__; destructors use __del__; the 'with' statement employs __enter__ and __exit__ instead.
- Creating objects in Python is considered more complex than in other languages due to the need for special methods and understanding of garbage collection.
Rewriting Jython
2 months ago
- Jython is a Java-based implementation of Python that enables using native Java classes in Python code.
- Its primary use is integrating with large Java codebases while retaining Python's readability.
- Python supports operator overloading via magic methods like __add__, with type safety enforced by the class.
- The implementation extensively uses Java's reflection API to achieve runtime method calls and duck typing.
- The current API includes only a NumberWrapper class for type promotion/demotion, with a ListWrapper in progress.
- The project is a toy without a full interpreter, demonstrated by calling add(new NumberWrapper(5), new NumberWrapper(-.14)).
- Output example shows 3.5 with no type warnings from javac due to reflection usage.
Intro to Python
2 months ago
- Python variables do not require explicit types, unlike Java where types must be declared (e.g., `i = 1` vs `int i = 1`).
- Python supports dynamic typing and duck-typing, allowing lists to hold mixed types (e.g., `l = [1, 1.2, 'hello, world']`), while Java requires generics or explicit typing.
- Python dictionaries can use non-integer keys (e.g., `{'Monday': 'MATH 374'}`), and indexing works similarly to lists.
- Python uses `**kwargs` to handle arbitrary keyword arguments in functions, whereas Java uses varargs with a functional interface like `IntConsumer`.
- Python's documentation uses triple-quoted strings with plain text, while Java's Javadoc uses `/** */` with HTML markup.
- Python's `print` function can be redefined to accept variable arguments using `*args`, similar to Java's varargs with `Object...`.
- Python supports lambda functions and higher-order functions (e.g., `call_with_one(lambda arg: print(arg))`) more syntactically flexibly than Java, which requires functional interfaces.
The Python Paradox
2 months ago
- The author claims that you can get smarter programmers for Python projects than Java projects because Python programmers learn the language out of genuine interest, not just for jobs.
- The Python paradox states that companies using esoteric languages attract better programmers since only those who care enough learn them.
- For programmers, the best language to learn for a good job is one that people don't learn merely to get a job.
- Programmers spend more time reading code than writing it, so language aesthetics matter; ugly code is maddening.
- Real ugliness in programming comes from building with wrong concepts, not just harsh syntax; Perl, despite superficial ugliness, can conceptually surpass Python in some cases.
- Languages like Python, Ruby, Lisp, and others are created by and used by people who care deeply about programming, leading to better programmers.
Jupyter notebooks as e2e tests
2 months ago
- Scientific Python libraries often use Jupyter notebooks for user guides and documentation.
- User guide notebooks can serve as effective end-to-end tests since they cover major use cases.
- Notebooks need to be parametrized (e.g., reading server URL from environment) to work both for users and CI pipelines.
- Two methods to run notebooks automatically: using nbclient (simple error detection) or nbconvert with jq (detailed output but harder error handling).
- The nbclient method works well for testing both documentation and code integrity on each merge request.
Printing floating point numbers in binary
2 months ago
- Hex to binary conversion works for floating point numbers similarly to integers, by converting each hex digit to binary.
- Python's float.hex() method returns a hex representation with a 'p' exponent indicating a power of 2, not 16.
- To get the binary representation, convert the hex digits after the point to binary using bin() on the integer value, then adjust the fraction point by the exponent.
- Padding with zeros may be necessary when converting hex digits to ensure correct bit alignment.
Ruff v0.16.0
2 months ago
- Ruff v0.16.0 now enables 413 rules by default, up from 59 in previous versions.
- The new default rules catch severe issues like syntax errors and runtime errors previously not enabled.
- Running the update on projects like Datasette, sqlite-utils, and LLM found hundreds of minor issues.
- The command `uvx ruff@latest check . --fix --unsafe-fixes` fixed most issues automatically.
- The author used AI coding agents (Codex and Claude Code) to upgrade the projects.
Ruff v0.16.0 – Significant new updates – 413 default rules up from 59
2 months ago
- Ruff v0.16.0 is released, installable via PyPI or package managers like `uv tool install ruff@latest`.
- The default rule set has expanded from 59 to 413 rules, incorporating many from flake8-bugbear and pyupgrade, catching more severe issues.
- New feature: Ruff can now format Python code blocks embedded in Markdown files, supporting various info strings.
- New suppression comments `ruff: ignore` and `ruff: file-ignore` provide finer control over linting, with `--add-ignore` flag for automation.
- Linter and formatter now display fixes (diff) in default output, and `format --check` supports multiple output formats.
- Multiple rules have been stabilized (e.g., AIR303, CPY001, FURB164) and several behavior stabilizations from preview are now default.
- Ruff is an extremely fast Python linter and formatter written in Rust, capable of replacing Black, Flake8, isort, and more.
Overloaded Overloading
2 months ago
- Python does not support method overloading (multiple methods with same name but different signatures). Only the last definition of a method is kept.
- Python does support operator overloading using magic methods like __add__, allowing operators like '+' to work differently for different types.
- The '+' operator works for both addition (numbers) and concatenation (strings) because float and str classes define their own __add__ methods.
- To simulate method overloading, you can write a dispatching method that checks argument types with isinstance() or presence of arguments.
- Alternatively, Python's functools.singledispatch decorator can be used for simpler cases of dispatching based on the first argument's type.
- The term 'overloading' has two different meanings in Python: method overloading (not supported) and operator overloading (supported).
Fixing a bug with byte order marks
2 months ago
- The author was converting SRT subtitle files to WebVTT format for use with HTML5 video on static websites.
- A bug occurred because byte order marks (BOM) in UTF-8 SRT files prevented proper removal of sequence numbers, leaving the BOM and first number in the output.
- The fix involved opening files with encoding='utf-8-sig' in Python to automatically strip the BOM.
- To repair already converted files, the author used ripgrep to find BOMs and a Python script to remove them from all .vtt files.
- The experience highlighted the importance of understanding low-level text encoding details when managing media files.
Splink – Fast, accurate and scalable probabilistic data linkage
2 months ago
- Splink is a Python package for probabilistic record linkage (entity resolution) that deduplicates and links records without unique identifiers.
- Key features include high speed (linking ~1 million records on a laptop in about a minute), accuracy with term frequency adjustments and fuzzy matching, and scalability via DuckDB, AWS Athena, or Spark for 100+ million records.
- It uses an unsupervised learning approach, requiring no training data, and provides interactive outputs for model understanding and diagnosis.
- The core algorithm is based on the Fellegi-Sunter model with customizations to improve accuracy.
- Best results are achieved with standardized, multi-column input data that are not highly correlated; it is not designed for single-column 'bag of words' data.
- Splink has been adopted by numerous organizations worldwide, including government agencies, healthcare institutions, and research groups, for tasks such as census linkage, business registers, and health record deduplication.
- It has received multiple awards, including the Civil Service Awards 2025 (Innovation and Excellence in Delivery) and OpenUK Awards 2025.
Show HN: Agent in 9 Lines Python
2 months ago
- The script is a minimal AI agent implemented in 9 lines of Python.
- It uses a custom tool to execute shell commands via subprocess based on model requests.
- The agent interacts with the user through command-line input, sends conversation history to a GPT-5.6 model API, and displays responses along with token usage.
What `for x in y` hides from you – From Scratch Code
2 months ago
- A Python 'for x in y' loop actually works by using an iterator protocol: it first calls iter(...) to get an iterator, then repeatedly calls next(...) to get values, and stops when StopIteration is raised.
- The for loop syntax is a wrapper that hides the underlying mechanism, which is the same for all iterable objects like lists, strings, ranges, and generators, making iteration feel unified and flexible.
- Understanding this reveals that iteration is not directly over the collection but over an iterator, which can be exhausted (like in the example where a second loop prints nothing after the first uses up the iterator).
- This design allows custom objects to participate in iteration by implementing __iter__() and __next__(), and explains why unpacking in loops (e.g., 'for x, y in pairs') works without special logic.
Gleam for Python Programmers
2 months ago
- Gleam is a programming language designed for Python programmers to learn functional programming concepts.
- The curriculum includes lessons from basics like types and functions to advanced topics like state machines and property-based testing.
- There are several project-based lessons, such as building a key-value store, a virtual machine, and web APIs.
- The appendices emphasize a pragmatic approach: start where you are, use available resources, and help others when possible.
Protobuf-py: Protobuf for Python, without compromises
3 months ago
- Introducing protobuf-py, a new Python-first Protocol Buffers library that passes the full conformance suite for proto2, proto3, and editions.
- Designed to offer both completeness (full spec support) and a Pythonic API, unlike Google's package (C++/Java-influenced) or betterproto (incomplete).
- Keeps message data in Python objects with __slots__, using a Rust accelerator for performance; faster than upb in real-world use cases like parsing and reading fields.
- Generates readable, typed Python code with relative imports, enabling better tooling support (e.g., pyright, mypy) without global type conflicts.
- Built by Buf, aligning with their ecosystem (Buf CLI, ConnectRPC), and is ready for use with buf.gen.yaml, with optional Rust acceleration and no runtime dependencies.
Performance Optimized Statically Typed Python
3 months ago
- POST Python is a performance optimized, statically typed subset of Python that is compilable.
- It runs unmodified under CPython and can be compiled to native code without a Python runtime.
- Functions can be interpreted as Python, compiled to native C kernels, or turned into numpy.ufuncs.
- It emphasizes a normative specification over informal subsets, with conformance profiles for tools.
- The reference compiler rejects unsupported semantics clearly, avoiding silent behavior changes.
- PostSciPy is rebuilding SciPy as POST Python libraries to discover language gaps and drive development.
- Current status includes structural checking, scalar kernels, vectorization, cross-module linking, and CPython extensions.
- Specification is a draft v0.2, and interfaces are subject to change.

firstprev0next

python

Logic for Programmers by Hillel Wayne

Terrible Horrible No Good Very Bad Python

Beej's Bit Bucket

Beej's Bit Bucket

Object Oriented Python

Rewriting Jython

Intro to Python

The Python Paradox

Jupyter notebooks as e2e tests

Printing floating point numbers in binary

Ruff v0.16.0

Ruff v0.16.0 – Significant new updates – 413 default rules up from 59

Overloaded Overloading

Fixing a bug with byte order marks

Splink – Fast, accurate and scalable probabilistic data linkage

Show HN: Agent in 9 Lines Python

What `for x in y` hides from you – From Scratch Code

Gleam for Python Programmers

Protobuf-py: Protobuf for Python, without compromises

Performance Optimized Statically Typed Python