Yes, there are the string justification methods, ljust and rjust.

>>> '12'.rjust(5, '#')
'###12'
>>> 'txt'.rjust(5, ' ')
'  txt'
>>> '12'.ljust(5, '#')
'12###'

Looking at Text | Text functions | ArcGIS Arcade | ArcGIS Developers

Text

Text(value, format?) -> Text

The format parameter is where you can specify the number of digits. For example:

var num = 12004;
return Text(num, '000000');

yields:

012004

If you want to make it dynamic, it is a bit cumbersome but doable:

var num = 12004;
var pad_len = 6;
var pad_char = 0;
return Text(num,  Concatenate(array(pad_len,pad_char)));

yields:

012004

As maybe a alternative more portable [1] and efficient [2], actually you can just use str.ljust.

In [2]: '190'.ljust(8, '0')
Out[2]: '19000000'

In [3]: str.ljust?
Docstring:
S.ljust(width[, fillchar]) -> str

Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
Type:      method_descriptor

[1] format is not present on old python versions. format specifier was added since Python 3.0 (see PEP 3101) and Python 2.6.

[2] reverse twice is an expensive operation.

there is no inbuilt zfill but I use this zfl function

def zfl(s, width):
# Pads the provided string with leading 0's to suit the specified 'chrs' length
# Force # characters, fill with leading 0's
return '{:0>{w}}'.format(s, w=width)

This might be useful to you? Just pass the string and the string width you require.

Edit: Polars 0.13.43 and later

With version 0.13.43 and later, Polars has a str.zfill expression to accomplish this. str.zfill will be faster than the answer below and thus str.zfill should be preferred.

From your question, I'm assuming that you are starting with a column of integers.

lambda x: str(x).zfill(5)

If so, here's one that adheres to pandas rather strictly:

import polars as pl
df = pl.DataFrame({"num": [-10, -1, 0, 1, 10, 100, 1000, 10000, 100000, 1000000, None]})

z = 5
df.with_columns(
    pl.when(pl.col("num").cast(pl.String).str.len_chars() > z)
    .then(pl.col("num").cast(pl.String))
    .otherwise(pl.concat_str(pl.lit("0" * z), pl.col("num").cast(pl.String)).str.slice(-z))
    .alias("result")
)

shape: (11, 2)
┌─────────┬─────────┐
│ num     ┆ result  │
│ ---     ┆ ---     │
│ i64     ┆ str     │
╞═════════╪═════════╡
│ -10     ┆ 00-10   │
│ -1      ┆ 000-1   │
│ 0       ┆ 00000   │
│ 1       ┆ 00001   │
│ 10      ┆ 00010   │
│ …       ┆ …       │
│ 1000    ┆ 01000   │
│ 10000   ┆ 10000   │
│ 100000  ┆ 100000  │
│ 1000000 ┆ 1000000 │
│ null    ┆ null    │
└─────────┴─────────┘

Comparing the output to pandas:

df.with_columns(pl.col('num').cast(pl.String)).get_column('num').to_pandas().str.zfill(z)

0       00-10
1       000-1
2       00000
3       00001
4       00010
5       00100
6       01000
7       10000
8      100000
9     1000000
10       None
dtype: object

If you are starting with strings, then you can simplify the code by getting rid any calls to cast.

Edit: On a dataset with 550 million records, this took about 50 seconds on my machine. (Note: this runs single-threaded)

Edit2: To shave off some time, you can use the following:

result = df.lazy().with_columns(
    pl.col('num').cast(pl.String).alias('tmp')
).with_columns(
    pl.when(pl.col("tmp").str.len_chars() > z)
    .then(pl.col("tmp"))
    .otherwise(pl.concat_str(pl.lit("0" * z), pl.col("tmp")).str.slice(-z))
    .alias("result")
).drop('tmp').collect()

but it didn't save that much time.