如何用零填充字符串？

2024-11-27 10:43:00
admin
原创
149
摘要：问题描述：如何在数字字符串左侧填充零，以使字符串具有特定的长度？解决方案 1：填充字符串：>>> n = '4' >>> print(n.zfill(3)) 004 填充数字：>>> n = 4 >>> print(f'{n:03}') ...

问题描述：

如何在数字字符串左侧填充零，以使字符串具有特定的长度？

解决方案 1：

填充字符串：

>>> n = '4'
>>> print(n.zfill(3))
004

填充数字：

>>> n = 4
>>> print(f'{n:03}') # Preferred method, python >= 3.6
004
>>> print('%03d' % n)
004
>>> print(format(n, '03')) # python >= 2.6
004
>>> print('{0:03d}'.format(n))  # python >= 2.6 + python 3
004
>>> print('{foo:03d}'.format(foo=n))  # python >= 2.6 + python 3
004
>>> print('{:03d}'.format(n))  # python >= 2.7 + python3
004

字符串格式化文档。

解决方案 2：

只需使用rjust字符串对象的方法。

此示例创建一个长度为 10 个字符的字符串，并根据需要进行填充：

>>> s = 'test'
>>> s.rjust(10, '0')
>>> '000000test'

解决方案 3：

对于使用f 字符串的 Python 3.6+ ：

>>> i = 1
>>> f"{i:0>2}"  # Works for both numbers and strings.
'01'
>>> f"{i:02}"  # Works only for numbers.
'01'

对于Python 2.6至 Python 3.5：

>>> "{:0>2}".format("1")  # Works for both numbers and strings.
'01'
>>> "{:02}".format(1)  # Works only for numbers.
'01'

这些标准格式说明符是[[fill]align][minimumwidth]和[0][minimumwidth]。

解决方案 4：

此外zfill，您还可以使用常规字符串格式：

print(f'{number:05d}') # (since Python 3.6), or
print('{:05d}'.format(number)) # or
print('{0:05d}'.format(number)) # or (explicit 0th positional arg. selection)
print('{n:05d}'.format(n=number)) # or (explicit `n` keyword arg. selection)
print(format(number, '05d'))

字符串格式和f 字符串的文档。

解决方案 5：

>>> '99'.zfill(5)
'00099'
>>> '99'.rjust(5,'0')
'00099'

如果你想要相反的结果：

>>> '99'.ljust(5,'0')
'99000'

解决方案 6：

str(n).zfill(width)将与strings、ints、floats... 一起使用，并且与 Python 2.x和3.x兼容：

>>> n = 3
>>> str(n).zfill(5)
'00003'
>>> n = '3'
>>> str(n).zfill(5)
'00003'
>>> n = '3.0'
>>> str(n).zfill(5)
'003.0'

解决方案 7：

在数字字符串左侧填充零的最具 Python 风格的方法是什么，即，使数字字符串具有特定的长度？

str.zfill专门用于执行此操作：

>>> '1'.zfill(4)
'0001'

请注意，它专门用于根据请求处理数字字符串，并将+或移动-到字符串的开头：

>>> '+1'.zfill(4)
'+001'
>>> '-1'.zfill(4)
'-001'

以下是 的帮助str.zfill：

>>> help(str.zfill)
Help on method_descriptor:

zfill(...)
    S.zfill(width) -> str

    Pad a numeric string S with zeros on the left, to fill a field
    of the specified width. The string S is never truncated.

表现

这也是替代方法中性能最高的：

>>> min(timeit.repeat(lambda: '1'.zfill(4)))
0.18824880896136165
>>> min(timeit.repeat(lambda: '1'.rjust(4, '0')))
0.2104538488201797
>>> min(timeit.repeat(lambda: f'{1:04}'))
0.32585487607866526
>>> min(timeit.repeat(lambda: '{:04}'.format(1)))
0.34988890308886766

为了最好地比较该方法%（注意它实际上更慢），否则将预先计算：

>>> min(timeit.repeat(lambda: '1'.zfill(0 or 4)))
0.19728074967861176
>>> min(timeit.repeat(lambda: '%04d' % (0 or 1)))
0.2347015216946602

执行

经过一番挖掘，我发现该zfill方法的实现如下Objects/stringlib/transmogrify.h：

static PyObject *
stringlib_zfill(PyObject *self, PyObject *args)
{
    Py_ssize_t fill;
    PyObject *s;
    char *p;
    Py_ssize_t width;

    if (!PyArg_ParseTuple(args, "n:zfill", &width))
        return NULL;

    if (STRINGLIB_LEN(self) >= width) {
        return return_self(self);
    }

    fill = width - STRINGLIB_LEN(self);

    s = pad(self, fill, 0, '0');

    if (s == NULL)
        return NULL;

    p = STRINGLIB_STR(s);
    if (p[fill] == '+' || p[fill] == '-') {
        /* move sign to beginning of string */
        p[0] = p[fill];
        p[fill] = '0';
    }

    return s;
}

让我们来看看这个 C 代码。

它首先按位置解析参数，这意味着它不允许关键字参数：

>>> '1'.zfill(width=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: zfill() takes no keyword arguments

然后检查它的长度是否相同或更长，如果是，则返回字符串。

>>> '1'.zfill(0)
'1'

zfill调用pad（此pad函数也被ljust、rjust和center调用）。这基本上将内容复制到新字符串中并填充填充。

static inline PyObject *
pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
{
    PyObject *u;

    if (left < 0)
        left = 0;
    if (right < 0)
        right = 0;

    if (left == 0 && right == 0) {
        return return_self(self);
    }

    u = STRINGLIB_NEW(NULL, left + STRINGLIB_LEN(self) + right);
    if (u) {
        if (left)
            memset(STRINGLIB_STR(u), fill, left);
        memcpy(STRINGLIB_STR(u) + left,
               STRINGLIB_STR(self),
               STRINGLIB_LEN(self));
        if (right)
            memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),
                   fill, right);
    }

    return u;
}

调用 之后pad，zfill将任何原本位于+或之前的字符移动-到字符串的开头。

请注意，原始字符串实际上不需要是数字：

>>> '+foo'.zfill(10)
'+000000foo'
>>> '-foo'.zfill(10)
'-000000foo'

解决方案 8：

对于那些来这里想要了解而不仅仅是快速回答的人来说。我专门针对时间字符串做了这些：

hour = 4
minute = 3
"{:0>2}:{:0>2}".format(hour,minute)
# prints 04:03

"{:0>3}:{:0>5}".format(hour,minute)
# prints '004:00003'

"{:0<3}:{:0<5}".format(hour,minute)
# prints '400:30000'

"{:$<3}:{:#<5}".format(hour,minute)
# prints '4$$:3####'

“0”符号用“2”填充字符替换，默认为空格

">" 符号将字符串左侧的所有 2 个“0”字符对齐

“:” 符号 format_spec

解决方案 9：

使用 Python 时>= 3.6，最干净的方法是使用带有字符串格式的f 字符串：

>>> s = f"{1:08}"  # inline with int
>>> s
'00000001'

>>> s = f"{'1':0>8}"  # inline with str
>>> s
'00000001'

>>> n = 1
>>> s = f"{n:08}"  # int variable
>>> s
'00000001'

>>> c = "1"
>>> s = f"{c:0>8}"  # str variable
>>> s
'00000001'

我更喜欢用 来格式化int，因为只有这样才能正确处理符号：

>>> f"{-1:08}"
'-0000001'

>>> f"{1:+08}"
'+0000001'

>>> f"{'-1':0>8}"
'000000-1'

解决方案 10：

对于数字：

i = 12
print(f"{i:05d}")

输出

00012

解决方案 11：

我正在添加如何在 f 字符串中使用字符串长度的 int，因为它似乎没有被涵盖：

>>> pad_number = len("this_string")
11
>>> s = f"{1:0{pad_number}}" }
>>> s
'00000000001'

解决方案 12：

width = 10
x = 5
print "%0*d" % (width, x)
> 0000000005

请参阅印刷文档以了解所有令人兴奋的细节！

针对 Python 3.x 的更新（7.5 年后）

最后一行现在应为：

print("%0*d" % (width, x))

ieprint()现在是一个函数，而不是语句。请注意，我仍然更喜欢老式printf()风格，因为在我看来，它读起来更好，而且因为，嗯，我从 1980 年 1 月开始就一直在使用这种符号。有些...老狗...有些...新花样。

解决方案 13：

对于保存为整数的邮政编码：

>>> a = 6340
>>> b = 90210
>>> print '%05d' % a
06340
>>> print '%05d' % b
90210

解决方案 14：

快速时间比较：

setup = '''
from random import randint
def test_1():
    num = randint(0,1000000)
    return str(num).zfill(7)
def test_2():
    num = randint(0,1000000)
    return format(num, '07')
def test_3():
    num = randint(0,1000000)
    return '{0:07d}'.format(num)
def test_4():
    num = randint(0,1000000)
    return format(num, '07d')
def test_5():
    num = randint(0,1000000)
    return '{:07d}'.format(num)
def test_6():
    num = randint(0,1000000)
    return '{x:07d}'.format(x=num)
def test_7():
    num = randint(0,1000000)
    return str(num).rjust(7, '0')
'''
import timeit
print timeit.Timer("test_1()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_2()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_3()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_4()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_5()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_6()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_7()", setup=setup).repeat(3, 900000)


> [2.281613943830961, 2.2719342631547077, 2.261691106209631]
> [2.311480238815406, 2.318420542148333, 2.3552384305184493]
> [2.3824197456864304, 2.3457239951596485, 2.3353268829498646]
> [2.312442972404032, 2.318053102249902, 2.3054072168069872]
> [2.3482314132374853, 2.3403386400002475, 2.330108825844775]
> [2.424549090688892, 2.4346475296851438, 2.429691196530058]
> [2.3259756401716487, 2.333549212826732, 2.32049893822186]

我做了不同次数的测试。差异并不大，但在所有测试中，zfill解决方案都是最快的。

解决方案 15：

如果您希望填充一个整数，并同时限制有效数字（使用 f 字符串）：

a = 4.432
>> 4.432
a = f'{a:04.1f}'
>> '04.4'

f'{a:04.1f}'这转换为 1 个小数/（浮点）点，左侧填充数字，直到总共 4 个字符。

解决方案 16：

也可以：

 h = 2
 m = 7
 s = 3
 print("%02d:%02d:%02d" % (h, m, s))

所以输出将是：“02:07:03”

解决方案 17：

您还可以重复“0”，将其添加到前面str(n)并获取最右边的宽度切片。快速而粗略的小表达。

def pad_left(n, width, pad="0"):
    return ((pad * width) + str(n))[-width:]

解决方案 18：

另一种方法是使用列表推导，并检查长度的条件。下面是一个演示：

# input list of strings that we want to prepend zeros
In [71]: list_of_str = ["101010", "10101010", "11110", "0000"]

# prepend zeros to make each string to length 8, if length of string is less than 8
In [83]: ["0"*(8-len(s)) + s if len(s) < desired_len else s for s in list_of_str]
Out[83]: ['00101010', '10101010', '00011110', '00000000']

解决方案 19：

我做了一个功能：

def PadNumber(number, n_pad, add_prefix=None):
    number_str = str(number)
    paded_number = number_str.zfill(n_pad)
    if add_prefix:
        paded_number = add_prefix+paded_number
    print(paded_number)

PadNumber(99, 4)
PadNumber(1011, 8, "b'")
PadNumber('7BEF', 6, "#")

输出：

0099
b'00001011
#007BEF
相关推荐
置顶 2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
  为什么项目管理通常仍然耗时且低效？您是否还在反复更新电子表格、淹没在便利贴中并参加每周更新会议？这确实是耗费时间和精力。借助软件工具的帮助，您可以一目了然地全面了解您的项目。如今，国内外有足够多优秀的项目管理软件可以帮助您掌控每个项目。什么是项目管理软件？项目管理软件是广泛行业用于项目规划、资源分配和调度的软件。它使项...
项目管理软件   1259  
IPD流程管理如何提升企业创新能力
IPD流程管理如何提升企业创新能力
  IPD（Integrated Product Development）流程管理作为一种先进的产品开发管理理念和方法，在提升企业创新能力方面发挥着至关重要的作用。它打破了传统产品开发过程中部门之间的壁垒，通过整合资源、优化流程，实现产品的快速、高效开发，为企业在激烈的市场竞争中赢得优势。IPD流程管理的核心概念IPD流程...
IPD流程中PDCP是什么意思   11  
IPD流程管理中的团队协作关键因素
IPD流程管理中的团队协作关键因素
  IPD（Integrated Product Development）流程管理作为一种先进的产品开发管理模式，旨在通过整合各种资源，实现产品的高效、高质量开发。在这一过程中，团队协作无疑是成功的关键。有效的团队协作能够打破部门壁垒，促进信息共享，提升决策效率，从而确保产品开发项目顺利推进。接下来，我们将深入探讨IPD流...
IPD培训课程   9  
IPD研发管理体系对项目周期的影响分析
IPD研发管理体系对项目周期的影响分析
  IPD（Integrated Product Development）研发管理体系作为一种先进的产品开发理念和方法，在众多企业中得到了广泛应用。它旨在打破部门壁垒，整合资源，实现产品开发的高效、协同与创新。在项目周期方面，IPD研发管理体系有着深远且多维度的影响，深入剖析这些影响，对于企业优化产品开发流程、提升市场竞争...
华为IPD流程   11  
IPD流程管理的五个阶段及其重要性
IPD流程管理的五个阶段及其重要性
  IPD（Integrated Product Development）流程管理是一种先进的产品开发管理模式，旨在通过整合企业的各种资源，实现产品的高效、高质量开发。它涵盖了从产品概念提出到产品退市的整个生命周期，对企业的发展具有至关重要的意义。接下来将详细阐述IPD流程管理的五个阶段及其重要性。概念阶段概念阶段是IPD...
IPD概念阶段   12  
热门文章
2024年项目管理软件排行榜
2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
img020
使用 Python 'Requests' 模块的代理
img044
10个项目管理常见问题解答：包括难点和解决方法
项目管理软件
项目延期的原因有哪些？如何有效预防和管理？
项目里程碑计划模板
项目里程碑计划模板怎么写?设定项目里程碑的5个方法
项目管理软件
项目管理指南：制定项目实施计划的6大步骤有哪些？
img081
工程项目管理中的团队建设与激励策略
项目管理软件有哪些？
热门标签
更多>
IPD流程 项目管理 IT项目管理 敏捷开发 项目管理软件 Scrum 敏捷项目管理 IPD流程管理 项目风险管理 项目管理工具 项目经理 极限编程  产品管理  项目经理职责 项目路线图 项目进度管理 测试管理工具 项目预算管理 PMP认证 瀑布式管理 项目范围管理 IT科技 项目管理平台 工程项目管理 项目资源管理 pmp证书考试
云禅道AD
禅道项目管理软件

云端的项目管理软件

尊享禅道项目软件收费版功能

无需维护，随时随地协同办公

内置subversion和git源码管理

每天备份，随时转为私有部署

免费试用