Question

我正在尝试创建一个python代码，可以帮助将下面的版本值增加1，预期的输出显示结果？我正在考虑将版本分开保存每个数字，将最后一位增加1并重建版本，有没有办法在python中简单地做到这一点？

version1 =  1151.1
version2 =  4.1.1
version3 = 275.1.2.99
version4 = 379

next_version1 = version1 + 1
print next_version1

next_version2 = version2 + 1
print next_version2

next_version3 = version3 + 1
print next_version3

next_version4 = version4 + 1
print next_version4

预期的输出：-

1151.2
4.1.2
275.1.2.100
380

Answer 1

实际上，在这种情况下，并非所有数字都是浮点数。

您应该将其视为字符串并更新最后一个元素。

version1 = '275.1.2.3'
version2 = '279'
version3 = '275.2.3.10'

def updateVersion(version):
    if '.' in version:
        version = version.split('.')
        version[-1] = str(int(version[-1]) + 1)
        version = '.'.join(version)
    else:
        version = str(int(version)+1)
    return version

updateVersion(version1)
updateVersion(version2)

输出：

275.1.2.4
280
275.2.3.11

Answer 2

请首先阅读有关Floating Point Arithmetic: Issues and Limitations

的信息

也许这就是你问的原因，不清楚。

但是，我建议将每个部分另存为整数，例如

listeners: {
    itemmouseenter: function (view, record, item, index, e, options)
    {
        if (e.getTarget().textContent.length > 11)
           Ext.QuickTips.register({
               text: e.getTarget().textContent,
               trackMouse: true,
               target: e.target
           });
    },
}

通过适当的方法，您可能具有包含这些字段的数据结构（也许是main_version_number = 1151 minor_version_number = 1 sub_version_number = 0类？）。

不要依赖浮点运算。

Answer 3

首先，您概述的代码肯定会给出语法错误。 2形式的数字是整数； 2.2，一个浮点；但是2.2.2，毫无意义。

您正在这里寻找元组。例如， >>> version3 = (275,1,2,3) 然后你会得到

>>> version3
(275, 1, 2, 3)

要仅脏更新这样一个元组的最后一位，可以执行

>>> version3 = version3[:-1] + (version3[-1] + 1,)
>>> version3
(275, 1, 2, 4)

我称此为“肮脏” 更新的原因是，它不会照顾到下一个有效位。

这是一个相对简单的脚本，只需几分钟即可完成。假设您已将版本号存储为名为version的元组对象，请尝试以下操作：

new_version = version
for bit in range(len(version)):
    new_version = new_version[:-1-bit] + ((new_version[-1-bit] + 1) % 10,) + new_version[-bit:]
    if -2-bit >=0:
        new_version = new_version[-2-bit:] + (new_version[-2-bit] + (version[-2-bit] + 1) // 10,) + new_version[-1-bit:]
    elif (version[-2-bit] + 1) // 10:
        new_version = (1,) + new_version

或者，看看bumpversion，它是一种工具，可以让您通过git集成来处理项目中的版本号。

Answer 4

变量'version2'和'version3'将导致语法错误。此语法错误是由以下事实引起的：Python不知道其值中包含多个点的任何（数字）类型。本质上，您试图以某种不被使用的方式使用某些类型。更具体地说，浮点数不适合您的目标。顾名思义，浮点数只能包含一个点，并且该点可以放置在其数字之间的任何位置（浮点）。

我的建议是创建自己的类型/类。这样一来，您就可以以易于修改其值的方式存储版本号，并更好地分离代码中的关注点（即，代码的每个部分仅涉及一件事）。

示例

class VersionNumber:
    """Represents a version number that can contain parts (major, minor, etc).""" 
    def __init__(self, *argv):
        """This is the constructor, i.e. a function that is called when you create a new VersionNumber.
        The '*argv' allows the user of this class to give a variable amount of arguments. This is why
        you can have a version number with only 1 number, and one with 4. The '*argv' is iterable."""

        #Create a class specific field, that stores all the version number parts in a list.
        self.Parts = []
        #Fill it with the supplied arguments.
        for part in argv:
            self.Parts.append(part)

    def __repr__(self):
        """This function is called when the VersionNumber needs to be displayed in the console"""
        return str(self)

    def __str__(self):
        """This function is called when the VersionNumber is parsed to a string"""
        return '.'.join(map(str,self.Parts))

    def incrementVersion(self, position, incrementAmount):
        """This function allows you to increment the version number. It does this by adjusting the list
        we have set in the constructor."""
        self.Parts[position] += incrementAmount


version1 = VersionNumber(1, 23, 45, 0)
print(version1)
#Position -1, takes the last (most right) version number part from the version number.
version1.incrementVersion(-1, 1)
print(version1)

version2 = VersionNumber(346)
print(version2)
version2.incrementVersion(-1, 2)
print(version2)

如何将浮点数加1？

4 个答案: