Coder Legion - Recent posts tagged formatting

Introducing PrettyPrint — a PHP array pretty-printer with Python-/PyTorch-style formatting

Sun, 14 Jun 2026 14:40:50 +0000

I'm excited to announce PrettyPrint, a small, zero-dependency PHP utility designed to format numeric arrays in a clean, readable style inspired by Python and the tensor-views you’ll see in PyTorch.

Whether you're doing ML experiments, debugging data pipelines, logging arrays, or building educational tools, PrettyPrint makes it easier to inspect array data in a structured way.

Why use PrettyPrint?

No extra dependencies - just pure PHP.

Supports aligned 2D tables, summarized tensor-style views (for larger arrays), 3D tensor with head/tail blocks, and flexible output options (labels, controlling newline behaviour, etc.).

Makes your array dumps more readable and visually helpful.

Quick Start & Examples

Installation

composer require apphp/pretty-print

Global helper functions

You can use the pprint() helper function for quick prints:

Print scalars/strings

pprint('Hello', 123, 4.56);
// Output:
// Hello 123 4.5600

1D / 2D examples

// Print multiple 1D rows aligned as a 2D table
pprint([1, 23, 456], [12, 3, 45]);
// Output:
// [[  1,  23, 456],
//  [12,   3,  45]]

Label + 2D matrix

pprint('Confusion matrix:', [[1,23], [456,7]]);
// Output:
// Confusion matrix:
// [[   1,  23],
//  [ 456,   7]]

Tensor / summarization example

$matrix = [
    [1, 2,  3,  4,  5],
    [6, 7,  8,  9, 10],
    [11,12, 13, 14, 15],
];
pprint($matrix);
// Output:
// tensor([
//   [  1,   2,   3,   4,   5],
//   [  6,   7,   8,   9,  10],
//   [ 11,  12,  13,  14,  15]
// ])

And for summarization (showing just head + tail of rows/cols):

pprint($matrix, headRows:1, tailRows:1, headCols:2, tailCols:2);
// Output:
// tensor([
//   [  1,   2,  ...,   4,   5],
//   ...,
//   [ 11,  12,  ...,  14,  15]
// ])

You can even print 3D tensor-like structures with summarised blocks:

$tensor3d = [
    [[1,2,3],[4,5,6]],
    [[7,8,9],[10,11,12]],
    [[13,14,15],[16,17,18]],
];
pprint($tensor3d, headB:1, tailB:1, headRows:1, tailRows:1, headCols:1, tailCols:1);
// Output:
// tensor([
//  [[ 1,  ...,  3],
//   [ 4,  ...,  6]],
//
//  ...,
//
//  [[13,  ..., 15],
//   [16,  ..., 18]]
// ])

Object-style usage

If you prefer, you can instantiate the printer as an object:

use Apphp\PrettyPrint\PrettyPrint;

$pp = new PrettyPrint();
$pp('Hello', 42);       // same as pprint('Hello', 42)

$pp($tensor3d, headB:2, tailB:1, headRows:1, tailRows:1, headCols:1, tailCols:1);
$pp('Metrics:', [[0.91, 0.02], [0.03, 0.88]]);

Options reference

Here are a few of the core options you can pass:

end (string) — line terminator (default: newline)
headB / tailB (ints) — number of 2D blocks shown for 3D tensors
headRows / tailRows — number of head/tail rows per slice with ellipsis between
headCols / tailCols — number of head/tail columns per slice with ellipsis between

Named-argument syntax (PHP 8+) is supported, or you can pass an array of options as last parameter.

Where it shines

ML/AI workflows: When you have numeric arrays or tensors in PHP (or imported from elsewhere) and want human-readable dumps.

Debugging & logging: Replace ad-hoc var_dump() or print_r() with structured, aligned table views.

Educational/teaching code: When showing matrix/tensor examples and you want a cleaner presentation.

CLI & scripts: For quick visual inspection of matrices/tensors in terminal output.

Final thoughts

I believe PrettyPrint fills a small but useful niche for PHP developers working with numeric data or coming from Python/PyTorch mindsets - offering readability, alignment, summarization, and minimal overhead.

Give it a spin:

GitHub: https://github.com/apphp/pretty-print
Packagist: https://packagist.org/packages/apphp/pretty-print

I'd love your feedback, suggestions for enhancements, or contributions — open an issue or PR and let’s make this tool even better together!

Happy coding!

You should know these f-string tricks in Python

Tue, 28 May 2024 22:46:17 +0000

Introduction

While Python programming is getting popular, mastering string formatting is foundational for every Python programmer! F-strings, introduced in Python 3.6, offer a different way to embed variables and expressions into strings, significantly improving code readability and maintainability. This guide compromises of advanced tips and tricks for using f-strings, helping you leverage their full potential.

Demostration

1. String Interpolation and Variable Names

By wrapping variables within curly braces, you can effortlessly embed their values into your text. Additionally, f-strings offer a unique feature that allows you to display both the variable name and its value, facilitating debugging and code comprehension.

# Define the variables
name = 'Cindy'
age = 30
        
#Display the values of the variables
print(f'{name} {age}')
        
# Display variable names alongside their values
print(f'{name=}, {age=}')

Note: The second example is known as self-documenting expression, which is introduced in Python 3.8. It can assist debugging by providing contextual information within the output.

Other formatting methods

name = 'Cindy'
age = 30

# Using %-formatting
print('%s %d' % (name, age))

# Using str.format()
print('{} {}'.format(name, age))

You may see that f-strings can format and display the value in a more organized way compared to other formatting methods.

2. Formatting Expressions

F-strings allow you to format the output of expressions directly within the string, presenting the data precisely based on your needs. For instance, you can specify formatting options such as precision for floating-point numbers, alignment for text, and padding for both text and numbers.

number = 25.644524

# 1. Format numeric value to two decimal places
print(f'{number:.2f}') 
    
# 2. Left, center, and right alignment
text = "HelloWorld"
print(f'{text:<20}')   # Left aligned
print(f'{text:^20}')   # Center aligned
print(f'{text:>20}')   # Right aligned

Other formatting methods

number = 25.644524

# Using %-formatting
print('%.2f' % number)

# Using str.format()
print('{:.2f}'.format(number))

While other formatting method also allow you to format the floating number, f-strings offer alignment and padding format in a more convenient way.

3. Inline Arithmetic and Function Calls

Moreover, f-strings also include arithmetic operations and function calls directly within the string interpolation. This allows you to perform calculations and call functions dynamically as part of the string formatting, reducing the need for intermediate variables and making your code more efficient and concise.

a = 32
b = 19

# 1. Inline arithmetic operations
print(f'{a + b}')
print(f'{a * b}')

# 2. Inline function calls
import math
radius = 10
print(f'Area of circle: {math.pi * radius ** 2:.2f}')

Other formatting methods

a = 32
b = 19

# Using %-formatting
print('%d' % (a + b))
print('%d' % (a * b))

# Using str.format()
print('{}' .format(a + b))
print('{}' .format(a * b))

4. Inline Arithmetic and Function Calls

F-strings allow you to include conditional logic directly within the string interpolation using Python's ternary conditional operator. This makes it possible to dynamically adjust the content and formatting of the string based on specific conditions, enhancing code readability and flexibility.

gender = "M"

# Conditional formatting
print(f'Gender is {"Male" if gender == "M" else "Female"}')

Practical Scenario

temperature = 33
print(f'Temperature is {"hot" if temperature > 30 else "cold" if temperature < 15 else "moderate"}')

5. Advanced String Manipulation

F-strings facilitate advanced string manipulation tasks such as slicing, concatenation, and applying string methods.

text = "Welcome to F-Strings!"

# Slicing and concatenation
print(f'{text[:5]} {text[-6:]}')

# Applying string methods
print(f'{text.lower()}')
print(f'{text.replace("Welcome", "Hello")}')

In addition to basic interpolation, f-strings can be used for more complex string manipulation tasks. You can perform slicing, concatenation, and apply various string methods within the f-string syntax. This makes f-strings a powerful tool for handling and transforming string data efficiently, often reducing the need for additional lines of code.

Other formatting methods

text = "Welcome to F-Strings!"

# Using %-formatting
print('%s %s' % (text[:5], text[-6:]))
print('%s' % text.lower())
print('%s' % text.replace("Welcome", "Hello"))

# Using str.format()
print('{} {}'.format(text[:5], text[-6:]))
print('{}'.format(text.lower()))
print('{}'.format(text.replace("Welcome", "Hello")))

From the comparison, you might see that f-strings offer shorter can cleaner code, and thus improve readability and understandability compared to others.

Wrapping Up

F-strings provide a powerful and efficient way to format strings in Python. From basic interpolation to advanced string manipulation and conditional formatting, f-strings streamline code and improve readability. By mastering these advanced tips and tricks, you can enhance your Python programming skills and write more maintainable code. Happy Coding!