Printf with variable format string

Due to @printf being a macro, it does not accept a format string that has been passed as a variable.

myvec = randn(4)
n = length(myvec)
outstring = "Beginning of string with some numbers:  "
for i = 1:n
   outstring = outstring*"%-12.3g"
outstring = outstring*"\n"
@printf(outstring, myvec...)

Is there currently a way to print using format strings without using a macro, or maybe a much smarter way I have failed to understand? The solution provided in

Changes the output for all Float64 which is undesirable in my case.

Thanks in advance!

1 Like perhaps. Seems that is needed for 0.6 though.


That seems to solve the problem nicely, thank you :slight_smile:

It’s been a long-standing issue and I hope it is resolved one day. I’ve been calling libc’s printf directly sometimes. In other situations, the definition

print_formatted(fmt, args...) = @eval @printf($fmt, $(args...))

comes in handy but is very slow. You can get an idea of how performance is affected here:

However, if you’re going to do lots of printing with one computed format string, @eval may be worthwhile. I use this approach when I know a format will be used many times, e.g.,


Thanks, in my intended application I will happily pay the performance penalty as long as it’s less than about 0.1s. Your solution seems to solve the problem just fine without the need for an additional package, thanks!

I think that a native function would be preferable instead of a package or the @eval solution.


I am personally not very fond of Formatting.jl - not enough lean

A short (and clean i hope) solution can be to gen closure with a macro according to the classical show signature

import Printf

macro gprintf(fmt::String)
    :((io::IO, arg) -> Printf.@printf(io, $fmt, arg))

# can be used like this
const fi = @gprintf "%d"
const f3p = @gprintf "%.3f"
const f6p = @gprintf "%.6f"
jit_printf(fmt) = @eval @gprintf($fmt)

using Test
@testset "printf_functionalization" begin
    @test sprint(f3p, 3.14) == "3.140"
    @test sprint(f6p, 3.14) == "3.140000"
    @testset for i in 3:8
        fmt = string("%.", i, "f")
        fjp = @eval @gprintf($fmt) # <=> fjp = jit_printf(fmt)
        @test sprint(fjp, 3.14) == "3.14" * repeat('0', i-2)

PS: BTW @RaulDurand that fix your point, no external package, no eval


still can’t use variable format strings with @printf in julia 1.9 :frowning:

julia> using Printf

julia> fmt = "%d"

julia> @printf fmt 16
ERROR: LoadError: ArgumentError: First argument to `@printf` after `io` must be a format string
 [1] var"@printf"(__source__::LineNumberNode, __module__::Module, io_or_fmt::Any, args::Vararg{Any})
   @ Printf ~/.julia/juliaup/
in expression starting at REPL[3]:1

try Printf.format()

thanks so much @Paul_Soderlind !

since format is not exported, and so isn’t documented, here’s specifically what i got to work:

julia> using Printf

julia> w=9

julia> fmt = Printf.Format("%$(w)d")
Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x25, 0x39, 0x64], UnitRange{Int64}[1:0, 4:3], (%9.0d,))

julia> Printf.format(stdout, fmt,16)
1 Like

What do you mean by “isn’t documented”? It is, in fact, documented. You have a link to its documentation in your post.

There is a docstring for Printf.Format:

julia> using Printf

help?> Printf.Format

  Create a C printf-compatible format object that can be used
  for formatting values.

  The input format_str can include any valid format specifier
  character and modifiers.

  A Format object can be passed to Printf.format(f::Format,
  args...) to produce a formatted string, or
  Printf.format(io::IO, f::Format, args...) to print the
  formatted string directly to io.

  For convenience, the Printf.format"..." string macro form
  can be used for building a Printf.Format object at

  │ Julia 1.6
  │  Printf.Format requires Julia 1.6 or later.

Edit: Sorry, I didn’t initially see that this response is identical to that of @fatteneder.

there is a docstring, yes, but what i was pointing out is that neither Printf.format nor Printf.Format are mentioned in the user manual. just trying to make it easier for folks until they are.

Imho, printf should not be a macro in the first place. In the end, its just a small performance optimization precompiling the format string, i.e., it doesn’t buy much as compared to its underlying functions:

julia> @macroexpand @printf "%d" 123
:((Printf).format(stdout, Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x25, 0x64], UnitRange{Int64}[1:0, 3:2], (%.0d,)), 123))

# So basically the same as
julia> Printf.format(stdout, Printf.format"%d", 123)
# i.e. with the format_str macro precompiling the Format
# Why not just define ...
julia> printf(fmt::Printf.Format, args...) = Printf.format(stdout, fmt, args...)

julia> printf(io::IO, fmt::Printf.Format, args...) = Printf.format(io, fmt, args...)

julia> macro fmt_str(s) Printf.Format(s) end

# and be happy
julia> printf(fmt"%d", 123)

Am I missing something here, i.e., also Rust decided on format being a macro?