标签归档：integer

将int转换为ASCII并返回Python

2021年8月17日 Python实用宝典

问题：将int转换为ASCII并返回Python

我正在为我的站点制作URL缩短器，而我目前的计划（我愿意接受建议）是使用节点ID来生成缩短的URL。因此，从理论上讲，节点26可能是short.com/z，节点1可能是short.com/a，节点52可能是short.com/Z，节点104可能是short.com/ZZ。当用户转到该URL时，我需要撤消该过程（显然）。

我可以想到一些可行的方法来解决此问题，但我想还有更好的方法。有什么建议？

I’m working on making a URL shortener for my site, and my current plan (I’m open to suggestions) is to use a node ID to generate the shortened URL. So, in theory, node 26 might be short.com/z, node 1 might be short.com/a, node 52 might be short.com/Z, and node 104 might be short.com/ZZ. When a user goes to that URL, I need to reverse the process (obviously).

I can think of some kludgy ways to go about this, but I’m guessing there are better ones. Any suggestions?

回答 0

ASCII转换为int：

ord('a')

给 97

然后返回一个字符串：

在Python2中： str(unichr(97))
在Python3中： chr(97)

给 'a'

ASCII to int:

ord('a')

gives 97

And back to a string:

in Python2: str(unichr(97))
in Python3: chr(97)

gives 'a'

回答 1

>>> ord("a")
97
>>> chr(97)
'a'

>>> ord("a")
97
>>> chr(97)
'a'

回答 2

如果多个字符绑定在一个整数/长整数内，这就是我的问题：

s = '0123456789'
nchars = len(s)
# string to int or long. Type depends on nchars
x = sum(ord(s[byte])<<8*(nchars-byte-1) for byte in range(nchars))
# int or long to string
''.join(chr((x>>8*(nchars-byte-1))&0xFF) for byte in range(nchars))

Yield'0123456789'和x = 227581098929683594426425L

If multiple characters are bound inside a single integer/long, as was my issue:

s = '0123456789'
nchars = len(s)
# string to int or long. Type depends on nchars
x = sum(ord(s[byte])<<8*(nchars-byte-1) for byte in range(nchars))
# int or long to string
''.join(chr((x>>8*(nchars-byte-1))&0xFF) for byte in range(nchars))

Yields '0123456789' and x = 227581098929683594426425L

回答 3

BASE58编码URL怎么样？像flickr这样。

# note the missing lowercase L and the zero etc.
BASE58 = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ' 
url = ''
while node_id >= 58:
    div, mod = divmod(node_id, 58)
    url = BASE58[mod] + url
    node_id = int(div)

return 'http://short.com/%s' % BASE58[node_id] + url

将其转换为数字也没什么大不了的。

What about BASE58 encoding the URL? Like for example flickr does.

# note the missing lowercase L and the zero etc.
BASE58 = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ' 
url = ''
while node_id >= 58:
    div, mod = divmod(node_id, 58)
    url = BASE58[mod] + url
    node_id = int(div)

return 'http://short.com/%s' % BASE58[node_id] + url

Turning that back into a number isn’t a big deal either.

回答 4

使用hex(id)[2:]和int(urlpart, 16)。还有其他选择。对您的id进行base32编码也可以正常工作，但是我不知道有没有内置Python进行base32编码的库。

显然，在Python 2.4中使用base64模块引入了base32编码器。您可以尝试使用b32encode和b32decode。你应该给True两者的casefold和map01期权b32decode的情况下，人们写下你的短网址。

实际上，我收回了这一点。我仍然认为base32编码是一个好主意，但是该模块对于URL缩短的情况没有用。您可以查看模块中的实现，并针对此特定情况进行自己的设计。:-)

Use hex(id)[2:] and int(urlpart, 16). There are other options. base32 encoding your id could work as well, but I don’t know that there’s any library that does base32 encoding built into Python.

Apparently a base32 encoder was introduced in Python 2.4 with the base64 module. You might try using b32encode and b32decode. You should give True for both the casefold and map01 options to b32decode in case people write down your shortened URLs.

Actually, I take that back. I still think base32 encoding is a good idea, but that module is not useful for the case of URL shortening. You could look at the implementation in the module and make your own for this specific case. :-)

知识问答

如何将布尔数组转换为int数组

2021年8月17日 Python实用宝典

问题：如何将布尔数组转换为int数组

我使用Scilab，并希望将布尔数组转换为整数数组：

>>> x = np.array([4, 3, 2, 1])
>>> y = 2 >= x
>>> y
array([False, False,  True,  True], dtype=bool)

在Scilab中，我可以使用：

>>> bool2s(y)
0.    0.    1.    1.

甚至只是将其乘以1：

>>> 1*y
0.    0.    1.    1.

在Python中是否有一个简单的命令，还是我必须使用循环？

I use Scilab, and want to convert an array of booleans into an array of integers:

>>> x = np.array([4, 3, 2, 1])
>>> y = 2 >= x
>>> y
array([False, False,  True,  True], dtype=bool)

In Scilab I can use:

>>> bool2s(y)
0.    0.    1.    1.

or even just multiply it by 1:

>>> 1*y
0.    0.    1.    1.

Is there a simple command for this in Python, or would I have to use a loop?

回答 0

numpy数组有一个astype方法。做吧y.astype(int)。

请注意，根据您使用数组的目的，甚至可能没有必要执行此操作。在许多情况下，Bool会自动提升为int，因此您可以将其添加到int数组中，而无需显式转换它：

>>> x
array([ True, False,  True], dtype=bool)
>>> x + [1, 2, 3]
array([2, 2, 4])

Numpy arrays have an astype method. Just do y.astype(int).

Note that it might not even be necessary to do this, depending on what you’re using the array for. Bool will be autopromoted to int in many cases, so you can add it to int arrays without having to explicitly convert it:

>>> x
array([ True, False,  True], dtype=bool)
>>> x + [1, 2, 3]
array([2, 2, 4])

回答 1

该1*y方法也适用于Numpy：

>>> import numpy as np
>>> x = np.array([4, 3, 2, 1])
>>> y = 2 >= x
>>> y
array([False, False,  True,  True], dtype=bool)
>>> 1*y                      # Method 1
array([0, 0, 1, 1])
>>> y.astype(int)            # Method 2
array([0, 0, 1, 1])

如果您正在寻求一种将Python列表从Boolean转换为int的方法，则可以使用以下map方法：

>>> testList = [False, False,  True,  True]
>>> map(lambda x: 1 if x else 0, testList)
[0, 0, 1, 1]
>>> map(int, testList)
[0, 0, 1, 1]

或使用列表推导：

>>> testList
[False, False, True, True]
>>> [int(elem) for elem in testList]
[0, 0, 1, 1]

The 1*y method works in Numpy too:

>>> import numpy as np
>>> x = np.array([4, 3, 2, 1])
>>> y = 2 >= x
>>> y
array([False, False,  True,  True], dtype=bool)
>>> 1*y                      # Method 1
array([0, 0, 1, 1])
>>> y.astype(int)            # Method 2
array([0, 0, 1, 1])

If you are asking for a way to convert Python lists from Boolean to int, you can use map to do it:

>>> testList = [False, False,  True,  True]
>>> map(lambda x: 1 if x else 0, testList)
[0, 0, 1, 1]
>>> map(int, testList)
[0, 0, 1, 1]

Or using list comprehensions:

>>> testList
[False, False, True, True]
>>> [int(elem) for elem in testList]
[0, 0, 1, 1]

回答 2

使用numpy，您可以执行以下操作：

y = x.astype(int)

如果您使用的是非numpy数组，则可以使用列表推导：

y = [int(val) for val in x]

Using numpy, you can do:

y = x.astype(int)

If you were using a non-numpy array, you could use a list comprehension:

y = [int(val) for val in x]

回答 3

大多数时候，您不需要转换：

>>>array([True,True,False,False]) + array([1,2,3,4])
array([2, 3, 3, 4])

正确的方法是：

yourArray.astype(int)

要么

yourArray.astype(float)

Most of the time you don’t need conversion:

>>>array([True,True,False,False]) + array([1,2,3,4])
array([2, 3, 3, 4])

The right way to do it is:

yourArray.astype(int)

yourArray.astype(float)

回答 4

我知道您要求使用非循环解决方案，但无论如何，我能想到的唯一解决方案可能是内部循环的：

map(int,y)

要么：

[i*1 for i in y]

要么：

import numpy
y=numpy.array(y)
y*1

I know you asked for non-looping solutions, but the only solutions I can come up with probably loop internally anyway:

map(int,y)

or:

[i*1 for i in y]

or:

import numpy
y=numpy.array(y)
y*1

回答 5

一个有趣的方法是

>>> np.array([True, False, False]) + 0 
np.array([1, 0, 0])

A funny way to do this is

>>> np.array([True, False, False]) + 0 
np.array([1, 0, 0])

知识问答

将浮点数向下舍入到最接近的整数？

2021年8月17日 Python实用宝典

问题：将浮点数向下舍入到最接近的整数？

如标题所示，我想取一个浮点数并将其四舍五入为最接近的整数。但是，如果它不是一个整数，那么我总是想舍入该变量，而不管它与下一个整数有多接近。有没有办法做到这一点？

As the title suggests, I want to take a floating point number and round it down to the nearest integer. However, if it’s not a whole, I ALWAYS want to round down the variable, regardless of how close it is to the next integer up. Is there a way to do this?

回答 0

简单

print int(x)

也会工作。

Simple

print int(x)

will work as well.

回答 1

其中之一应起作用：

import math
math.trunc(1.5)
> 1
math.trunc(-1.5)
> -1
math.floor(1.5)
> 1
math.floor(-1.5)
> -2

One of these should work:

import math
math.trunc(1.5)
> 1
math.trunc(-1.5)
> -1
math.floor(1.5)
> 1
math.floor(-1.5)
> -2

回答 2

x//1

该//运算符返回师的地板上。由于除以1不会更改您的数字，所以这等于下限，但不需要导入。笔记：

这将返回一个浮点数
向-∞取整

x//1

The // operator returns the floor of the division. Since dividing by 1 doesn’t change your number, this is equivalent to floor but no import is needed. Notes:

This returns a float
This rounds towards -∞

回答 3

要获取浮点结果，只需使用：

round(x-0.5)

它也适用于负数。

To get floating point result simply use:

round(x-0.5)

It works for negative numbers as well.

回答 4

我认为您需要一个下限功能：

math.floor（x）

I think you need a floor function :

math.floor(x)

回答 5

很多人说可以使用int(x)，并且在大多数情况下都可以使用，但是存在一些问题。如果OP的结果是：

x = 1.9999999999999999

它会四舍五入

x = 2

9月16日之后，它会四舍五入。如果您确定您永远不会遇到这种事情，那么这并不是什么大不了的事情。但这是要牢记的。

a lot of people say to use int(x), and this works ok for most cases, but there is a little problem. If OP’s result is:

x = 1.9999999999999999

it will round to

x = 2

after the 16th 9 it will round. This is not a big deal if you are sure you will never come across such thing. But it’s something to keep in mind.

回答 6

如果您不想导入数学，则可以使用：

int(round(x))

这是一个文档：

>>> help(round)
Help on built-in function round in module __builtin__:

round(...)
    round(number[, ndigits]) -> floating point number

    Round a number to a given precision in decimal digits (default 0 digits).
    This always returns a floating point number.  Precision may be negative.

If you don’t want to import math, you could use:

int(round(x))

Here’s a piece of documentation:

>>> help(round)
Help on built-in function round in module __builtin__:

round(...)
    round(number[, ndigits]) -> floating point number

    Round a number to a given precision in decimal digits (default 0 digits).
    This always returns a floating point number.  Precision may be negative.

回答 7

如果您使用numpy，则可以使用以下解决方案，该解决方案也适用于负数（它也适用于数组）

import numpy as np
def round_down(num):
    if num < 0:
        return -np.ceil(abs(num))
    else:
        return np.int32(num)
round_down = np.vectorize(round_down)

round_down([-1.1, -1.5, -1.6, 0, 1.1, 1.5, 1.6])
> array([-2., -2., -2.,  0.,  1.,  1.,  1.])

我认为如果仅使用math模块而不是numpy模块，它也将起作用。

If you working with numpy, you can use the following solution which also works with negative numbers (it’s also working on arrays)

import numpy as np
def round_down(num):
    if num < 0:
        return -np.ceil(abs(num))
    else:
        return np.int32(num)
round_down = np.vectorize(round_down)

round_down([-1.1, -1.5, -1.6, 0, 1.1, 1.5, 1.6])
> array([-2., -2., -2.,  0.,  1.,  1.,  1.])

I think it will also work if you just use the math module instead of numpy module.

回答 8

不知道您是否解决了这个问题，但我偶然发现了这个问题。如果要去除小数点，可以使用int（x），它将消除所有十进制数字。无需使用round（x）。

Don’t know if you solved this, but I just stumble upon this question. If you want to get rid of decimal points, you could use int(x) and it will eliminate all decimal digits. Theres no need to use round(x).

回答 9

只需取整（x-0.5），这将始终返回您的Float的下一个四舍五入的Integer值。您也可以通过do round（x + 0.5）轻松地四舍五入

Just make round(x-0.5) this will always return the next rounded down Integer value of your Float. You can also easily round up by do round(x+0.5)

回答 10

这可能很简单，但是您难道不可以将其舍去然后减去1吗？例如：

number=1.5
round(number)-1
> 1

It may be very simple, but couldn’t you just round it up then minus 1? For example:

number=1.5
round(number)-1
> 1

回答 11

我用此代码从数字中减去0.5，然后将其四舍五入，即原始数字四舍五入。

圆（a-0.5）

I used this code where you subtract 0.5 from the number and when you round it, it is the original number rounded down.

round(a-0.5)

知识问答

Python如何管理int和long？

2021年8月17日 Python实用宝典

问题：Python如何管理int和long？

有人知道Python如何在内部管理int和long类型吗？

它会动态选择合适的类型吗？
一个整数的限制是多少？
我正在使用Python 2.6，与以前的版本有所不同吗？

我应该如何理解以下代码？

>>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

更新：

>>> print type(0x7fffffff)
<type 'int'>
>>> print type(0x80000000)
<type 'long'>

Does anybody know how Python manage internally int and long types?

Does it choose the right type dynamically?
What is the limit for an int?
I am using Python 2.6, Is is different with previous versions?

How should I understand the code below?

>>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

Update:

>>> print type(0x7fffffff)
<type 'int'>
>>> print type(0x80000000)
<type 'long'>

回答 0

int并long“统一” 了几个版本。在此之前，可以通过数学运算来溢出int。

3.x通过完全消除long而仅具有int来进一步提高了此功能。

Python 2：sys.maxint包含Python int可以容纳的最大值。
- 在64位Python 2.7上，大小为24个字节。用检查sys.getsizeof()。
Python 3：sys.maxsize包含Python int可以达到的最大字节数。
- 这将是32位的千兆字节和64位的EB。
- 如此大的int的值将等于8的幂sys.maxsize。

int and long were “unified” a few versions back. Before that it was possible to overflow an int through math ops.

3.x has further advanced this by eliminating long altogether and only having int.

Python 2: sys.maxint contains the maximum value a Python int can hold.
- On a 64-bit Python 2.7, the size is 24 bytes. Check with sys.getsizeof().
Python 3: sys.maxsize contains the maximum size in bytes a Python int can be.
- This will be gigabytes in 32 bits, and exabytes in 64 bits.
- Such a large int would have a value similar to 8 to the power of sys.maxsize.

回答 1

该PEP应该有所帮助。

最重要的是，在python版本> 2.4中，您真的不必担心它

This PEP should help.

Bottom line is that you really shouldn’t have to worry about it in python versions > 2.4

回答 2

在我的机器上：

>>> print type(1<<30)
<type 'int'>
>>> print type(1<<31)
<type 'long'>
>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'long'>

Python使用整数（32位带符号整数，我不知道它们是否是C整数）适合适合32位的值，但是对于任何东西，它都会自动切换为长整数（任意大的位数，即bignums）更大。我猜想这将加快速度以提供较小的值，同时通过无缝过渡到bignum避免任何溢出。

On my machine:

>>> print type(1<<30)
<type 'int'>
>>> print type(1<<31)
<type 'long'>
>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'long'>

Python uses ints (32 bit signed integers, I don’t know if they are C ints under the hood or not) for values that fit into 32 bit, but automatically switches to longs (arbitrarily large number of bits – i.e. bignums) for anything larger. I’m guessing this speeds things up for smaller values while avoiding any overflows with a seamless transition to bignums.

回答 3

有趣。在我的64位（i7 Ubuntu）盒子上：

>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'int'>

猜猜它在更大的机器上提升到64位整数。

Interesting. On my 64-bit (i7 Ubuntu) box:

>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'int'>

Guess it steps up to 64 bit ints on a larger machine.

回答 4

Python 2.7.9自动提升数字。对于不确定使用int（）或long（）的情况。

>>> a = int("123")
>>> type(a)
<type 'int'>
>>> a = int("111111111111111111111111111111111111111111111111111")
>>> type(a)
<type 'long'>

Python 2.7.9 auto promotes numbers. For a case where one is unsure to use int() or long().

>>> a = int("123")
>>> type(a)
<type 'int'>
>>> a = int("111111111111111111111111111111111111111111111111111")
>>> type(a)
<type 'long'>

回答 5

Python 2将根据值的大小自动设置类型。最大值指南可在下面找到。

Python 2中默认Int的Max值为65535，任何高于此值的值都会很长

例如：

>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

在Python 3中，长数据类型已被删除，所有整数值都由Int类处理。Int的默认大小将取决于您的CPU体系结构。

例如：

32位系统，整数的默认数据类型为’Int32′
64位系统，整数的默认数据类型将为’Int64′

每种类型的最小值/最大值可在下面找到：

Int8：[-128,127]
Int16：[-32768,32767]
Int32：[-2147483648,2147483647]
Int64：[-9223372036854775808,9223372036854775807]
Int128：[-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
UInt8：[0,255]
UInt16：[0,65535]
UInt32：[0,4294967295]
UInt64：[0,18446744073709551615]
UInt128：[0,340282366920938938463463374607431768211455]

如果您的Int大小超过上述限制，python将自动更改其类型并分配更多内存以处理此最小值/最大值的增加。在Python 2中，它将转换为“ long”，现在仅转换为下一个Int大小。

示例：如果您使用的是32位操作系统，则Int的最大值默认为2147483647。如果分配的值为2147483648或更大，则类型将更改为Int64。

有多种方法可以检查int的大小及其内存分配。注意：在Python 3中，<class 'int'>无论您使用的是什么Int大小，使用内置的type（）方法总是会返回。

Python 2 will automatically set the type based on the size of the value. A guide of max values can be found below.

The Max value of the default Int in Python 2 is 65535, anything above that will be a long

For example:

>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

In Python 3 the long datatype has been removed and all integer values are handled by the Int class. The default size of Int will depend on your CPU architecture.

For example:

32 bit systems the default datatype for integers will be ‘Int32’
64 bit systems the default datatype for integers will be ‘Int64’

The min/max values of each type can be found below:

Int8: [-128,127]
Int16: [-32768,32767]
Int32: [-2147483648,2147483647]
Int64: [-9223372036854775808,9223372036854775807]
Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
UInt8: [0,255]
UInt16: [0,65535]
UInt32: [0,4294967295]
UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

If the size of your Int exceeds the limits mentioned above, python will automatically change it’s type and allocate more memory to handle this increase in min/max values. Where in Python 2, it would convert into ‘long’, it now just converts into the next size of Int.

Example: If you are using a 32 bit operating system, your max value of an Int will be 2147483647 by default. If a value of 2147483648 or more is assigned, the type will be changed to Int64.

There are different ways to check the size of the int and it’s memory allocation. Note: In Python 3, using the built-in type() method will always return <class 'int'> no matter what size Int you are using.

回答 6

从python 3.x开始，统一整数库比旧版本更加智能。在（i7 Ubuntu）盒子上，我得到了以下信息：

>>> type(math.factorial(30))
<class 'int'>

有关实现的详细信息，请参见Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.c文件。最后一个文件是动态模块（编译为so文件）。该代码很好地遵循。

From python 3.x, the unified integer libries are even more smarter than older versions. On my (i7 Ubuntu) box I got the following,

>>> type(math.factorial(30))
<class 'int'>

For implementation details refer Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.c files. The last file is a dynamic module (compiled to an so file). The code is well commented to follow.

回答 7

只是为了继续这里给出的所有答案，尤其是@James Lanes

整数类型的大小可以通过以下公式表示：

总范围=（2 ^位系统）

下限=-（2 ^位系统）* 0.5上限=（（2 ^位系统）* 0.5）-1

Just to continue to all the answers that were given here, especially @James Lanes

the size of the integer type can be expressed by this formula:

total range = (2 ^ bit system)

lower limit = -(2 ^ bit system)*0.5 upper limit = ((2 ^ bit system)*0.5) – 1

回答 8

它管理着他们，因为int和long是同级类定义。它们具有用于+，-，*，/等的适当方法，这些方法将产生适当类的结果。

例如

>>> a=1<<30
>>> type(a)
<type 'int'>
>>> b=a*2
>>> type(b)
<type 'long'>

在这种情况下，该类int具有一个__mul__方法（实现*的方法），该方法可long在需要时创建结果。

It manages them because int and long are sibling class definitions. They have appropriate methods for +, -, *, /, etc., that will produce results of the appropriate class.

For example

>>> a=1<<30
>>> type(a)
<type 'int'>
>>> b=a*2
>>> type(b)
<type 'long'>

In this case, the class int has a __mul__ method (the one that implements *) which creates a long result when required.

知识问答

为什么Python 3允许“ 00”作为0的文字，却不允许“ 01”作为1的文字？

2021年8月11日 Python实用宝典

问题：为什么Python 3允许“ 00”作为0的文字，却不允许“ 01”作为1的文字？

为什么Python 3允许“ 00”作为原义的0，却不允许“ 01”作为原义的1？有充分的理由吗？这种矛盾使我感到困惑。（我们正在谈论的是Python 3，它故意打破了向后兼容性以实现诸如一致性之类的目标。）

例如：

>>> from datetime import time
>>> time(16, 00)
datetime.time(16, 0)
>>> time(16, 01)
  File "<stdin>", line 1
    time(16, 01)
              ^
SyntaxError: invalid token
>>>

Why does Python 3 allow “00” as a literal for 0 but not allow “01” as a literal for 1? Is there a good reason? This inconsistency baffles me. (And we’re talking about Python 3, which purposely broke backward compatibility in order to achieve goals like consistency.)

For example:

>>> from datetime import time
>>> time(16, 00)
datetime.time(16, 0)
>>> time(16, 01)
  File "<stdin>", line 1
    time(16, 01)
              ^
SyntaxError: invalid token
>>>

回答 0

根据https://docs.python.org/3/reference/lexical_analysis.html#integer-literals：

整数文字由以下词汇定义描述：

integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
decimalinteger ::=  nonzerodigit digit* | "0"+
nonzerodigit   ::=  "1"..."9"
digit          ::=  "0"..."9"
octinteger     ::=  "0" ("o" | "O") octdigit+
hexinteger     ::=  "0" ("x" | "X") hexdigit+
bininteger     ::=  "0" ("b" | "B") bindigit+
octdigit       ::=  "0"..."7"
hexdigit       ::=  digit | "a"..."f" | "A"..."F"
bindigit       ::=  "0" | "1"

除了可以存储在可用内存中的整数之外，整数文字的长度没有限制。

请注意，不允许使用非零十进制数字开头的零。这是为了消除C样式八进制文字的歧义，Python在3.0版之前使用了这些样式。

如此处所述，不允许使用非零十进制数字开头的零。"0"+作为一个非常特殊的情况是合法的，这在Python 2中是不存在的：

integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
decimalinteger ::=  nonzerodigit digit* | "0"
octinteger     ::=  "0" ("o" | "O") octdigit+ | "0" octdigit+

SVN commit r55866在令牌生成器中实现了PEP 3127，它禁止使用旧0<octal>数字。但是，奇怪的是，它也添加了以下注释：

/* in any case, allow '0' as a literal */

带有nonzero仅SyntaxError在以下数字序列包含非零数字时抛出的特殊标志。

这很奇怪，因为PEP 3127不允许这种情况：

该PEP建议，将使用Python 3.0（和2.6的Python 3.0预览模式）从语言中删除使用前导零指定八进制数的功能，并且每当前导“ 0”为紧跟着另一个数字。

（强调我的）

因此，允许多个零的事实在技术上违反了PEP，并且基本上由Georg Brandl实施为特殊情况。他进行了相应的文档更改，以注意这"0"+是的有效案例decimalinteger（以前已在中进行了介绍octinteger）。

我们可能永远不会确切知道为什么Georg选择使之"0"+有效-在Python中它可能永远是一个奇怪的情况。

更新 [2015年7月28日]：这个问题引发了关于python-ideas 的热烈讨论，Georg在其中进行了讨论：

史蒂文·达普拉诺（Steven D’Aprano）写道：

为什么这样定义？[…]为什么我们写0000以得到零？

我可以告诉你，但后来我不得不杀了你。

格奥尔格

后来，该线程生成了此错误报告，旨在摆脱这种特殊情况。乔治在这里说：

我不记得有意进行更改的原因（从文档更改中可以看出）。

我现在无法提出更改的充分理由[…]

因此，我们有了它：这种不一致背后的确切原因已不复存在。

最后，请注意，该错误报告已被拒绝：对于Python 3.x的其余部分，前导零将仅在零整数上继续被接受。

Per https://docs.python.org/3/reference/lexical_analysis.html#integer-literals:

Integer literals are described by the following lexical definitions:
integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
decimalinteger ::=  nonzerodigit digit* | "0"+
nonzerodigit   ::=  "1"..."9"
digit          ::=  "0"..."9"
octinteger     ::=  "0" ("o" | "O") octdigit+
hexinteger     ::=  "0" ("x" | "X") hexdigit+
bininteger     ::=  "0" ("b" | "B") bindigit+
octdigit       ::=  "0"..."7"
hexdigit       ::=  digit | "a"..."f" | "A"..."F"
bindigit       ::=  "0" | "1"
There is no limit for the length of integer literals apart from what can be stored in available memory.

Note that leading zeros in a non-zero decimal number are not allowed. This is for disambiguation with C-style octal literals, which Python used before version 3.0.

As noted here, leading zeros in a non-zero decimal number are not allowed. "0"+ is legal as a very special case, which wasn’t present in Python 2:

integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
decimalinteger ::=  nonzerodigit digit* | "0"
octinteger     ::=  "0" ("o" | "O") octdigit+ | "0" octdigit+

SVN commit r55866 implemented PEP 3127 in the tokenizer, which forbids the old 0<octal> numbers. However, curiously, it also adds this note:

/* in any case, allow '0' as a literal */

with a special nonzero flag that only throws a SyntaxError if the following sequence of digits contains a nonzero digit.

This is odd because PEP 3127 does not allow this case:

This PEP proposes that the ability to specify an octal number by using a leading zero will be removed from the language in Python 3.0 (and the Python 3.0 preview mode of 2.6), and that a SyntaxError will be raised whenever a leading “0” is immediately followed by another digit.

(emphasis mine)

So, the fact that multiple zeros are allowed is technically violating the PEP, and was basically implemented as a special case by Georg Brandl. He made the corresponding documentation change to note that "0"+ was a valid case for decimalinteger (previously that had been covered under octinteger).

We’ll probably never know exactly why Georg chose to make "0"+ valid – it may forever remain an odd corner case in Python.

UPDATE [28 Jul 2015]: This question led to a lively discussion thread on python-ideas in which Georg chimed in:

Steven D’Aprano wrote:

Why was it defined that way? […] Why would we write 0000 to get zero?

I could tell you, but then I’d have to kill you.

Georg

Later on, the thread spawned this bug report aiming to get rid of this special case. Here, Georg says:

I don’t recall the reason for this deliberate change (as seen from the docs change).

I’m unable to come up with a good reason for this change now […]

and thus we have it: the precise reason behind this inconsistency is lost to time.

Finally, note that the bug report was rejected: leading zeros will continue to be accepted only on zero integers for the rest of Python 3.x.

回答 1

这是特例（"0"+）

2.4.4。整数文字

整数文字由以下词汇定义描述：

整数:: =十进制整数| 八进制| hexinteger | 二进制整数
十进制整数:: =非零数字* “ 0” +
非零数字:: =“ 1” ...“ 9”
数字:: =“ 0” ...“ 9”
八位整数:: =“ 0”（“ o” |“ O”）八位数字+
hexinteger :: =“ 0”（“ x” |“ X”）十六进制+
bininteger :: =“ 0”（“ b” |“ B”）bindigit +
八位数字:: =“ 0” ...“ 7”
十六进制::: digit | “ a” ...“ f” | “ A” ...“ F”
bindigit :: =“ 0” | “ 1”

如果您查看语法，则很容易看到0需要特殊情况。我不确定为什么在+那里需要’ ‘。是时候浏览一下开发邮件列表了…

有趣的是，在Python2中，有多个0解析为octinteger（最终结果仍然0是）

十进制整数:: =非零数字* “ 0”
八位整数:: =“ 0”（“ o” |“ O”）八位数字+ | “ 0”八位数字+

It’s a special case ("0"+)

2.4.4. Integer literals

Integer literals are described by the following lexical definitions:

integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
decimalinteger ::=  nonzerodigit digit* | "0"+
nonzerodigit   ::=  "1"..."9"
digit          ::=  "0"..."9"
octinteger     ::=  "0" ("o" | "O") octdigit+
hexinteger     ::=  "0" ("x" | "X") hexdigit+
bininteger     ::=  "0" ("b" | "B") bindigit+
octdigit       ::=  "0"..."7"
hexdigit       ::=  digit | "a"..."f" | "A"..."F"
bindigit       ::=  "0" | "1"

If you look at the grammar, it’s easy to see that 0 need a special case. I’m not sure why the ‘+‘ is considered necessary there though. Time to dig through the dev mailing list…

Interesting to note that in Python2, more than one 0 was parsed as an octinteger (the end result is still 0 though)

decimalinteger ::=  nonzerodigit digit* | "0"
octinteger     ::=  "0" ("o" | "O") octdigit+ | "0" octdigit+

回答 2

Python2使用前导零指定八进制数：

>>> 010
8

为了避免这种情况（？误导性）行为，Python3需要明确的前缀0b，0o，0x：

>>> 0o10
8

Python2 used the leading zero to specify octal numbers:

>>> 010
8

To avoid this (misleading?) behaviour, Python3 requires explicit prefixes 0b, 0o, 0x:

>>> 0o10
8

知识问答

从整数列表中，获取最接近给定值的数字

2021年8月4日 Python实用宝典

问题：从整数列表中，获取最接近给定值的数字

给定一个整数列表，我想找到哪个数字与我在输入中提供的数字最接近：

>>> myList = [4, 1, 88, 44, 3]
>>> myNumber = 5
>>> takeClosest(myList, myNumber)
...
4

有什么快速的方法可以做到这一点吗？

Given a list of integers, I want to find which number is the closest to a number I give in input:

>>> myList = [4, 1, 88, 44, 3]
>>> myNumber = 5
>>> takeClosest(myList, myNumber)
...
4

Is there any quick way to do this?

回答 0

如果不确定列表是否已排序，则可以使用内置min()函数，查找与指定数字之间的最小距离的元素。

>>> min(myList, key=lambda x:abs(x-myNumber))
4

请注意，它也可用于带有int键的字典，例如{1: "a", 2: "b"}。此方法花费O（n）时间。

如果列表已经排序，或者您可以只对数组进行一次排序，则使用@Lauritz答案中所示的二等分方法，该方法只需要O（log n）时间（但请注意，检查列表是否已排序为O）（n），排序为O（n log n）。）

If we are not sure that the list is sorted, we could use the built-in min() function, to find the element which has the minimum distance from the specified number.

>>> min(myList, key=lambda x:abs(x-myNumber))
4

Note that it also works with dicts with int keys, like {1: "a", 2: "b"}. This method takes O(n) time.

If the list is already sorted, or you could pay the price of sorting the array once only, use the bisection method illustrated in @Lauritz’s answer which only takes O(log n) time (note however checking if a list is already sorted is O(n) and sorting is O(n log n).)

回答 1

我将重命名该函数take_closest以符合PEP8命名约定。

如果您的意思是快速执行而不是快速编写，min那么除非是在一个非常狭窄的用例中，否则不应将其作为选择的武器。该min解决方案需要检查列表中的每一个数字，并做到每个号码的计算。使用bisect.bisect_left替代几乎总是更快。

“几乎”来自bisect_left要求对列表进行排序才能工作的事实。希望您的用例能够对列表进行一次排序，然后再将其保留。即使不是，只要您不需要在每次调用之前进行排序take_closest，该bisect模块就可能排在最前面。如果您有疑问，请尝试两者并查看实际差异。

from bisect import bisect_left

def take_closest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.

    If two numbers are equally close, return the smallest number.
    """
    pos = bisect_left(myList, myNumber)
    if pos == 0:
        return myList[0]
    if pos == len(myList):
        return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before

Bisect的工作方式是反复将列表减半，并myNumber通过查看中间值找出必须放入的一半。这意味着它的运行时间为O（log n），而不是最高投票答案的O（n）运行时间。如果我们比较这两种方法并同时提供两种myList，则结果如下：

$ python -m timeit -s“
从最近的导入take_closest
来自随机进口randint
a = range（-1000，1000，10）“” take_closest（a，randint（-1100，1100））“

100000次循环，每循环3：2.22最佳

$ python -m timeit -s“
最接近的导入with_min
来自随机进口randint
a = range（-1000，1000，10）“” with_min（a，randint（-1100，1100））“

10000次循环，最好为3次：每个循环43.9微秒

因此，在此特定测试中，bisect速度快了将近20倍。对于更长的列表，差异会更大。

如果我们通过消除myList必须排序的前提条件来公平地竞争该怎么办？假设我们在每次 take_closest调用时对列表的副本进行排序，而min解决方案保持不变。使用上述测试中的200个项目列表，该bisect解决方案仍然是最快的，尽管只有30％。

考虑到排序步骤为O（n log（n）），这是一个奇怪的结果！唯一min仍然丢失的原因是，排序是在高度优化的C代码中完成的，而min必须为每个项目调用lambda函数。随着myList规模的增长，min解决方案最终将更快。请注意，min为了赢得解决方案，我们必须堆叠所有有利条件。

I’ll rename the function take_closest to conform with PEP8 naming conventions.

If you mean quick-to-execute as opposed to quick-to-write, min should not be your weapon of choice, except in one very narrow use case. The min solution needs to examine every number in the list and do a calculation for each number. Using bisect.bisect_left instead is almost always faster.

The “almost” comes from the fact that bisect_left requires the list to be sorted to work. Hopefully, your use case is such that you can sort the list once and then leave it alone. Even if not, as long as you don’t need to sort before every time you call take_closest, the bisect module will likely come out on top. If you’re in doubt, try both and look at the real-world difference.

from bisect import bisect_left

def take_closest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.

    If two numbers are equally close, return the smallest number.
    """
    pos = bisect_left(myList, myNumber)
    if pos == 0:
        return myList[0]
    if pos == len(myList):
        return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before

Bisect works by repeatedly halving a list and finding out which half myNumber has to be in by looking at the middle value. This means it has a running time of O(log n) as opposed to the O(n) running time of the highest voted answer. If we compare the two methods and supply both with a sorted myList, these are the results:

$ python -m timeit -s "
from closest import take_closest
from random import randint
a = range(-1000, 1000, 10)" "take_closest(a, randint(-1100, 1100))"

100000 loops, best of 3: 2.22 usec per loop

$ python -m timeit -s "
from closest import with_min
from random import randint
a = range(-1000, 1000, 10)" "with_min(a, randint(-1100, 1100))"

10000 loops, best of 3: 43.9 usec per loop

So in this particular test, bisect is almost 20 times faster. For longer lists, the difference will be greater.

What if we level the playing field by removing the precondition that myList must be sorted? Let’s say we sort a copy of the list every time take_closest is called, while leaving the min solution unaltered. Using the 200-item list in the above test, the bisect solution is still the fastest, though only by about 30%.

This is a strange result, considering that the sorting step is O(n log(n))! The only reason min is still losing is that the sorting is done in highly optimalized c code, while min has to plod along calling a lambda function for every item. As myList grows in size, the min solution will eventually be faster. Note that we had to stack everything in its favour for the min solution to win.

回答 2

>>> takeClosest = lambda num,collection:min(collection,key=lambda x:abs(x-num))
>>> takeClosest(5,[4,1,88,44,3])
4

一个拉姆达是写一个“匿名”功能（即没有名称的功能）的一种特殊方式。您可以为它分配任何名称，因为lambda是一个表达式。

上面的“长篇”写法是：

def takeClosest(num,collection):
   return min(collection,key=lambda x:abs(x-num))

>>> takeClosest = lambda num,collection:min(collection,key=lambda x:abs(x-num))
>>> takeClosest(5,[4,1,88,44,3])
4

A lambda is a special way of writing an “anonymous” function (a function that doesn’t have a name). You can assign it any name you want because a lambda is an expression.

The “long” way of writing the the above would be:

def takeClosest(num,collection):
   return min(collection,key=lambda x:abs(x-num))

回答 3

def closest(list, Number):
    aux = []
    for valor in list:
        aux.append(abs(Number-valor))

    return aux.index(min(aux))

此代码将为您提供列表中最接近的Number的索引。

KennyTM提供的解决方案是最好的整体解决方案，但是在您无法使用它的情况下（例如brython），此功能可以完成工作

def closest(list, Number):
    aux = []
    for valor in list:
        aux.append(abs(Number-valor))

    return aux.index(min(aux))

This code will give you the index of the closest number of Number in the list.

The solution given by KennyTM is the best overall, but in the cases you cannot use it (like brython), this function will do the work

回答 4

遍历列表，然后将当前最接近的数字与进行比较abs(currentNumber - myNumber)：

def takeClosest(myList, myNumber):
    closest = myList[0]
    for i in range(1, len(myList)):
        if abs(i - myNumber) < closest:
            closest = i
    return closest

Iterate over the list and compare the current closest number with abs(currentNumber - myNumber):

def takeClosest(myList, myNumber):
    closest = myList[0]
    for i in range(1, len(myList)):
        if abs(i - myNumber) < closest:
            closest = i
    return closest

回答 5

重要的是要注意，Lauritz的使用bisect的建议思想实际上并未在MyList中找到与MyNumber最接近的值。相反，bisect会在MyList中的MyNumber之后按顺序查找下一个值。因此，在OP的情况下，您实际上得到的是返回的位置44而不是位置4。

>>> myList = [1, 3, 4, 44, 88] 
>>> myNumber = 5
>>> pos = (bisect_left(myList, myNumber))
>>> myList[pos]
...
44

要获得最接近5的值，您可以尝试将列表转换为数组，并使用numpy的argmin这样。

>>> import numpy as np
>>> myNumber = 5   
>>> myList = [1, 3, 4, 44, 88] 
>>> myArray = np.array(myList)
>>> pos = (np.abs(myArray-myNumber)).argmin()
>>> myArray[pos]
...
4

我不知道这会有多快，我的猜测是“不太”。

It’s important to note that Lauritz’s suggestion idea of using bisect does not actually find the closest value in MyList to MyNumber. Instead, bisect finds the next value in order after MyNumber in MyList. So in OP’s case you’d actually get the position of 44 returned instead of the position of 4.

>>> myList = [1, 3, 4, 44, 88] 
>>> myNumber = 5
>>> pos = (bisect_left(myList, myNumber))
>>> myList[pos]
...
44

To get the value that’s closest to 5 you could try converting the list to an array and using argmin from numpy like so.

>>> import numpy as np
>>> myNumber = 5   
>>> myList = [1, 3, 4, 44, 88] 
>>> myArray = np.array(myList)
>>> pos = (np.abs(myArray-myNumber)).argmin()
>>> myArray[pos]
...
4

I don’t know how fast this would be though, my guess would be “not very”.

回答 6

扩展了古斯塔沃·利马（Gustavo Lima）的答案。无需创建全新的列表即可完成相同的操作。随着FOR循环的进行，列表中的值可以用差分代替。

def f_ClosestVal(v_List, v_Number):
"""Takes an unsorted LIST of INTs and RETURNS INDEX of value closest to an INT"""
for _index, i in enumerate(v_List):
    v_List[_index] = abs(v_Number - i)
return v_List.index(min(v_List))

myList = [1, 88, 44, 4, 4, -2, 3]
v_Num = 5
print(f_ClosestVal(myList, v_Num)) ## Gives "3," the index of the first "4" in the list.

Expanding upon Gustavo Lima’s answer. The same thing can be done without creating an entirely new list. The values in the list can be replaced with the differentials as the FOR loop progresses.

def f_ClosestVal(v_List, v_Number):
"""Takes an unsorted LIST of INTs and RETURNS INDEX of value closest to an INT"""
for _index, i in enumerate(v_List):
    v_List[_index] = abs(v_Number - i)
return v_List.index(min(v_List))

myList = [1, 88, 44, 4, 4, -2, 3]
v_Num = 5
print(f_ClosestVal(myList, v_Num)) ## Gives "3," the index of the first "4" in the list.

回答 7

如果我可以补充@Lauritz的答案

为了避免出现运行错误，请不要忘记在该bisect_left行之前添加一个条件：

if (myNumber > myList[-1] or myNumber < myList[0]):
    return False

因此完整的代码如下所示：

from bisect import bisect_left

def takeClosest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.
    If two numbers are equally close, return the smallest number.
    If number is outside of min or max return False
    """
    if (myNumber > myList[-1] or myNumber < myList[0]):
        return False
    pos = bisect_left(myList, myNumber)
    if pos == 0:
            return myList[0]
    if pos == len(myList):
            return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before

If I may add to @Lauritz’s answer

In order not to have a run error don’t forget to add a condition before the bisect_left line:

if (myNumber > myList[-1] or myNumber < myList[0]):
    return False

so the full code will look like:

from bisect import bisect_left

def takeClosest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.
    If two numbers are equally close, return the smallest number.
    If number is outside of min or max return False
    """
    if (myNumber > myList[-1] or myNumber < myList[0]):
        return False
    pos = bisect_left(myList, myNumber)
    if pos == 0:
            return myList[0]
    if pos == len(myList):
            return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before

知识问答

Python整数除法产生浮点数

2021年8月2日 Python实用宝典

问题：Python整数除法产生浮点数

Python 3.1 (r31:73574, Jun 26 2009, 20:21:35) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 2/2
1.0

这是故意的吗？我强烈记得以前的版本返回了int/int=int吗？我该怎么办，有没有新的分公司运营商，或者我必须始终选拔？

Python 3.1 (r31:73574, Jun 26 2009, 20:21:35) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 2/2
1.0

Is this intended? I strongly remember earlier versions returning int/int=int? What should I do, is there a new division operator or must I always cast?

回答 0

看看PEP-238：更改除法运算符

//运算符将可用于明确要求楼层分割。

Take a look at PEP-238: Changing the Division Operator

The // operator will be available to request floor division unambiguously.

回答 1

糟糕，立即发现2//2。

Oops, immediately found 2//2.

回答 2

希望它可以立即帮助某人。

Python 2.7和Python 3中除法运算符的行为

在Python 2.7中：默认情况下，除法运算符将返回整数输出。

将结果以1.0的两倍倍数除以 “除数或除数”

100/35 => 2 #(Expected is 2.857142857142857)
(100*1.0)/35 => 2.857142857142857
100/(35*1.0) => 2.857142857142857

在Python 3中

// => used for integer output
/ => used for double output

100/35 => 2.857142857142857
100//35 => 2
100.//35 => 2.0    # floating-point result if divsor or dividend real

Hope it might help someone instantly.

Behavior of Division Operator in Python 2.7 and Python 3

In Python 2.7: By default, division operator will return integer output.

to get the result in double multiple 1.0 to “dividend or divisor”

100/35 => 2 #(Expected is 2.857142857142857)
(100*1.0)/35 => 2.857142857142857
100/(35*1.0) => 2.857142857142857

In Python 3

// => used for integer output
/ => used for double output

100/35 => 2.857142857142857
100//35 => 2
100.//35 => 2.0    # floating-point result if divsor or dividend real

回答 3

接受的答案已经提到了PEP 238。我只想为那些对正在发生的事情感兴趣的人快速了解幕后情况，而无需阅读整个PEP。

Python将运算符+（-，，*和）映射/到特殊函数，例如a + b相当于

a.__add__(b)

关于在Python 2分割，存在通过仅仅默认/映射到__div__，其结果是依赖于输入类型（例如int，float）。

Python 2.2引入了__future__功能division，该功能通过以下方式更改了分割语义（PEP 238的TL; DR）：

/__truediv__必须“返回除法的数学结果的合理近似值”的映射（来自PEP 238的引用）
//映射到__floordiv__，应返回的底数结果/

在Python 3.0中，PEP 238的更改成为默认行为，并且__div__Python对象模型中没有其他特殊方法。

如果要在Python 2和Python 3中使用相同的代码，请使用

from __future__ import division

并坚持到PEP的238个语义/和//。

The accepted answer already mentions PEP 238. I just want to add a quick look behind the scenes for those interested in what’s going on without reading the whole PEP.

Python maps operators like +, -, * and / to special functions, such that e.g. a + b is equivalent to

a.__add__(b)

Regarding division in Python 2, there is by default only / which maps to __div__ and the result is dependent on the input types (e.g. int, float).

Python 2.2 introduced the __future__ feature division, which changed the division semantics the following way (TL;DR of PEP 238):

/ maps to __truediv__ which must “return a reasonable approximation of the mathematical result of the division” (quote from PEP 238)
// maps to __floordiv__, which should return the floored result of /

With Python 3.0, the changes of PEP 238 became the default behaviour and there is no more special method __div__ in Python’s object model.

If you want to use the same code in Python 2 and Python 3 use

from __future__ import division

and stick to the PEP 238 semantics of / and //.

回答 4

根据Python3文档，python除以整数后，尽管预期为整数，但仍会生成浮点数。

对于仅打印整数，请使用floor division method。楼层除法将四舍五入并除去小数点。Represented by //

因此，使用2/2代替 2//2

__future__无论使用python2还是python3，也可以从中导入除法。

希望能帮助到你！

According to Python3 documentation,python when divided by integer,will generate float despite expected to be integer.

For exclusively printing integer,use floor division method. Floor division is rounding off zero and removing decimal point. Represented by //

Hence,instead of 2/2 ,use 2//2

You can also import division from __future__ irrespective of using python2 or python3.

Hope it helps!

知识问答

在Python中将float转换为整数的最安全方法？

2021年8月2日 Python实用宝典

问题：在Python中将float转换为整数的最安全方法？

Python的math模块包含诸如floor＆的便捷函数ceil。这些函数采用浮点数，并在其下或上返回最接近的整数。但是，这些函数将答案作为浮点数返回。例如：

import math
f=math.floor(2.3)

现在f返回：

2.0

从该浮点数中获取整数而不冒取舍入错误风险的最安全方法是什么（例如，如果浮点数等于1.99999），或者我应该完全使用另一个函数？

Python’s math module contain handy functions like floor & ceil. These functions take a floating point number and return the nearest integer below or above it. However these functions return the answer as a floating point number. For example:

import math
f=math.floor(2.3)

Now f returns:

2.0

What is the safest way to get an integer out of this float, without running the risk of rounding errors (for example if the float is the equivalent of 1.99999) or perhaps I should use another function altogether?

回答 0

可以用浮点数表示的所有整数均具有精确的表示形式。这样您就可以安全地使用int结果了。仅当您尝试使用非2的幂的分母来表示有理数时，才会出现不精确的表示。

这项工作一点都不小！IEEE浮点表示的一个属性是int∘floor=⌊⋅⌋，如果所讨论的数字的大小足够小，但是int（floor（2.3））可能为1的情况下，可能会有不同的表示形式。

要引用维基百科，

绝对值小于或等于2 ^24的任何整数都可以用单精度格式准确表示，绝对值小于或等于2 ^53的任何整数都可以用双精度格式准确表示。

All integers that can be represented by floating point numbers have an exact representation. So you can safely use int on the result. Inexact representations occur only if you are trying to represent a rational number with a denominator that is not a power of two.

That this works is not trivial at all! It’s a property of the IEEE floating point representation that int∘floor = ⌊⋅⌋ if the magnitude of the numbers in question is small enough, but different representations are possible where int(floor(2.3)) might be 1.

To quote from Wikipedia,

Any integer with absolute value less than or equal to 2²⁴ can be exactly represented in the single precision format, and any integer with absolute value less than or equal to 2⁵³ can be exactly represented in the double precision format.

回答 1

使用int(your non integer number)将打钉。

print int(2.3) # "2"
print int(math.sqrt(5)) # "2"

Use int(your non integer number) will nail it.

print int(2.3) # "2"
print int(math.sqrt(5)) # "2"

回答 2

您可以使用舍入功能。如果您不使用第二个参数（有效数字位数），那么我认为您将获得想要的行为。

空闲输出。

>>> round(2.99999999999)
3
>>> round(2.6)
3
>>> round(2.5)
3
>>> round(2.4)
2

You could use the round function. If you use no second parameter (# of significant digits) then I think you will get the behavior you want.

IDLE output.

>>> round(2.99999999999)
3
>>> round(2.6)
3
>>> round(2.5)
3
>>> round(2.4)
2

回答 3

结合之前的两个结果，我们得到：

int(round(some_float))

这可以相当可靠地将浮点数转换为整数。

Combining two of the previous results, we have:

int(round(some_float))

This converts a float to an integer fairly dependably.

回答 4

这项工作一点都不小！IEEE浮点表示的一个属性是int∘floor=⌊⋅⌋，如果所讨论的数字的大小足够小，但是int（floor（2.3））可能为1的情况下，可能会有不同的表示形式。

这篇文章解释了为什么它可以在这个范围内工作。

在double中，您可以毫无问题地表示32位整数。有不能是任何四舍五入问题。更精确地，双精度数可以表示2 ⁵³和-2 ⁵³之间（包括2 ⁵³和-2 ^53）的所有整数。

简短说明：一个double最多可以存储53个二进制数字。当您需要更多时，该数字将在右边填充零。

由此可见，53个数字是无需填充即可存储的最大数字。自然，所有需要较少数字的（整数）数字都可以准确存储。

将111加1（省略）111（53个）将产生100 … 000，（53个零）。众所周知，我们可以存储53位数字，即最右边的零填充。

这是2 ^53的来源。

详细信息：我们需要考虑IEEE-754浮点如何工作。

  1 bit    11 / 8     52 / 23      # bits double/single precision
[ sign |  exponent | mantissa ]

然后，该数字的计算方式如下（不包括此处无关的特殊情况）：

-1 ^号 ×1.尾数×2 ^{指数-偏差}

其中偏压= 2 ^{指数- 1} 1 –分别，即，1023和127，用于双/单精度。

明知乘以2 ^X根本改变所有位X位的左侧，可以很容易地看到，任何整数必须具备的所有位尾数为此右上小数点零。

除零以外的任何整数都具有以下二进制形式：

1x … x，其中x -es表示MSB右侧的位（最高有效位）。

因为我们排除了零，所以总会有一个MSB为1，这就是为什么不存储它的原因。要存储整数，我们必须将其转换为上述形式：-1 ^符号 ×1.尾数×2 ^指数偏差。

就是说，将这些位移到小数点后直到只有MSB朝MSB的左侧移动。然后，小数点右边的所有位都存储在尾数中。

由此可见，除MSB外，我们最多可以存储52个二进制数字。

因此，显式存储所有位的最高编号为

111(omitted)111.   that's 53 ones (52 + implicit 1) in the case of doubles.

为此，我们需要设置指数，以使小数点后移52位。如果我们将指数增加一，我们将无法知道小数点后左边的数字。

111(omitted)111x.

按照惯例，它是0。将整个尾数设置为零，我们收到以下数字：

100(omitted)00x. = 100(omitted)000.

这是一个1，后跟53个零，已存储52个，并且由于指数而加了1。

它代表2 ⁵³，它标志着我们可以准确表示所有整数的边界（负向和正向）。如果要将1加到2 ⁵³，则必须将隐式零（由表示x）设置为1，但这是不可能的。

That this works is not trivial at all! It’s a property of the IEEE floating point representation that int∘floor = ⌊⋅⌋ if the magnitude of the numbers in question is small enough, but different representations are possible where int(floor(2.3)) might be 1.

This post explains why it works in that range.

In a double, you can represent 32bit integers without any problems. There cannot be any rounding issues. More precisely, doubles can represent all integers between and including 2⁵³ and -2⁵³.

Short explanation: A double can store up to 53 binary digits. When you require more, the number is padded with zeroes on the right.

It follows that 53 ones is the largest number that can be stored without padding. Naturally, all (integer) numbers requiring less digits can be stored accurately.

Adding one to 111(omitted)111 (53 ones) yields 100…000, (53 zeroes). As we know, we can store 53 digits, that makes the rightmost zero padding.

This is where 2⁵³ comes from.

More detail: We need to consider how IEEE-754 floating point works.

  1 bit    11 / 8     52 / 23      # bits double/single precision
[ sign |  exponent | mantissa ]

The number is then calculated as follows (excluding special cases that are irrelevant here):

-1^sign × 1.mantissa ×2^{exponent – bias}

where bias = 2^{exponent – 1} – 1, i.e. 1023 and 127 for double/single precision respectively.

Knowing that multiplying by 2^X simply shifts all bits X places to the left, it’s easy to see that any integer must have all bits in the mantissa that end up right of the decimal point to zero.

Any integer except zero has the following form in binary:

1x…x where the x-es represent the bits to the right of the MSB (most significant bit).

Because we excluded zero, there will always be a MSB that is one—which is why it’s not stored. To store the integer, we must bring it into the aforementioned form: -1^sign × 1.mantissa ×2^{exponent – bias}.

That’s saying the same as shifting the bits over the decimal point until there’s only the MSB towards the left of the MSB. All the bits right of the decimal point are then stored in the mantissa.

From this, we can see that we can store at most 52 binary digits apart from the MSB.

It follows that the highest number where all bits are explicitly stored is

111(omitted)111.   that's 53 ones (52 + implicit 1) in the case of doubles.

For this, we need to set the exponent, such that the decimal point will be shifted 52 places. If we were to increase the exponent by one, we cannot know the digit right to the left after the decimal point.

111(omitted)111x.

By convention, it’s 0. Setting the entire mantissa to zero, we receive the following number:

100(omitted)00x. = 100(omitted)000.

That’s a 1 followed by 53 zeroes, 52 stored and 1 added due to the exponent.

It represents 2⁵³, which marks the boundary (both negative and positive) between which we can accurately represent all integers. If we wanted to add one to 2⁵³, we would have to set the implicit zero (denoted by the x) to one, but that’s impossible.

回答 5

math.floor将始终返回整数，因此int(math.floor(some_float))永远不会引入舍入错误。

但是，舍入错误可能已经引入了math.floor(some_large_float)，或者甚至当首先将大量存储在float中时也已引入。（存储在浮点数中的大数字可能会失去精度。）

math.floor will always return an integer number and thus int(math.floor(some_float)) will never introduce rounding errors.

The rounding error might already be introduced in math.floor(some_large_float), though, or even when storing a large number in a float in the first place. (Large numbers may lose precision when stored in floats.)

回答 6

如果需要将字符串float转换为int，则可以使用此方法。

例如：'38.0'到38

为了将其转换为int，可以将其转换为float，然后转换为int。这也适用于浮点字符串或整数字符串。

>>> int(float('38.0'))
38
>>> int(float('38'))
38

注意：这将删除小数点后的所有数字。

>>> int(float('38.2'))
38

If you need to convert a string float to an int you can use this method.

Example: '38.0' to 38

In order to convert this to an int you can cast it as a float then an int. This will also work for float strings or integer strings.

>>> int(float('38.0'))
38
>>> int(float('38'))
38

Note: This will strip any numbers after the decimal.

>>> int(float('38.2'))
38

回答 7

另一个代码示例使用变量将实数/浮点数转换为整数。“ vel”是一个实数/浮点数，并转换为第二高的整数“ newvel”。

import arcpy.math, os, sys, arcpy.da
.
.
with arcpy.da.SearchCursor(densifybkp,[floseg,vel,Length]) as cursor:
 for row in cursor:
    curvel = float(row[1])
    newvel = int(math.ceil(curvel))

Another code sample to convert a real/float to an integer using variables. “vel” is a real/float number and converted to the next highest INTEGER, “newvel”.

import arcpy.math, os, sys, arcpy.da
.
.
with arcpy.da.SearchCursor(densifybkp,[floseg,vel,Length]) as cursor:
 for row in cursor:
    curvel = float(row[1])
    newvel = int(math.ceil(curvel))

回答 8

由于您要求的是“最安全”的方式，因此我将提供除最佳答案之外的另一个答案。

确保您不损失任何精度的一种简单方法是检查转换后的值是否相等。

if int(some_value) == some_value:
     some_value = int(some_value)

例如，如果float为1.0，则1.0等于1。因此将执行向int的转换。如果float为1.1，则int（1.1）等于1，并且1.1！=1。因此，该值将保持为float值，并且不会损失任何精度。

Since you’re asking for the ‘safest’ way, I’ll provide another answer other than the top answer.

An easy way to make sure you don’t lose any precision is to check if the values would be equal after you convert them.

if int(some_value) == some_value:
     some_value = int(some_value)

If the float is 1.0 for example, 1.0 is equal to 1. So the conversion to int will execute. And if the float is 1.1, int(1.1) equates to 1, and 1.1 != 1. So the value will remain a float and you won’t lose any precision.

回答 9

df [‘Column_Name’] = df [‘Column_Name’]。astype（int）

df[‘Column_Name’]=df[‘Column_Name’].astype(int)

知识问答

在python中将整数转换为二进制

2021年8月2日 Python实用宝典

问题：在python中将整数转换为二进制

为了将整数转换为二进制，我使用了以下代码：

>>> bin(6)  
'0b110'

什么时候擦除“ 0b”，我用这个：

>>> bin(6)[2:]  
'110'

我能做些什么，如果我想展现6的00000110，而不是110？

In order to convert an integer to a binary, I have used this code :

>>> bin(6)  
'0b110'

and when to erase the ‘0b’, I use this :

>>> bin(6)[2:]  
'110'

What can I do if I want to show 6 as 00000110 instead of 110?

回答 0

>>> '{0:08b}'.format(6)
'00000110'

仅说明格式化字符串的部分：

{} 将变量放入字符串
0 将变量放在参数位置0
:为该变量添加格式设置选项（否则它将代表小数6）
08 将数字格式化为左侧零填充的八位数字
b 将数字转换为其二进制表示形式

如果您使用的是Python 3.6或更高版本，则还可以使用f字符串：

>>> f'{6:08b}'
'00000110'

>>> '{0:08b}'.format(6)
'00000110'

Just to explain the parts of the formatting string:

{} places a variable into a string
0 takes the variable at argument position 0
: adds formatting options for this variable (otherwise it would represent decimal 6)
08 formats the number to eight digits zero-padded on the left
b converts the number to its binary representation

If you’re using a version of Python 3.6 or above, you can also use f-strings:

>>> f'{6:08b}'
'00000110'

回答 1

只是另一个想法：

>>> bin(6)[2:].zfill(8)
'00000110'

通过字符串插值（Python 3.6+）的更短方法：

>>> f'{6:08b}'
'00000110'

Just another idea:

>>> bin(6)[2:].zfill(8)
'00000110'

Shorter way via string interpolation (Python 3.6+):

>>> f'{6:08b}'
'00000110'

回答 2

有点纠结的方法…

>>> bin8 = lambda x : ''.join(reversed( [str((x >> i) & 1) for i in range(8)] ) )
>>> bin8(6)
'00000110'
>>> bin8(-3)
'11111101'

A bit twiddling method…

>>> bin8 = lambda x : ''.join(reversed( [str((x >> i) & 1) for i in range(8)] ) )
>>> bin8(6)
'00000110'
>>> bin8(-3)
'11111101'

回答 3

只需使用格式功能

format(6, "08b")

一般形式是

format(<the_integer>, "<0><width_of_string><format_specifier>")

Just use the format function

format(6, "08b")

The general form is

format(<the_integer>, "<0><width_of_string><format_specifier>")

回答 4

eumiro的答案更好，但是我只是发布此内容以供参考：

>>> "%08d" % int(bin(6)[2:])
00000110

eumiro’s answer is better, however I’m just posting this for variety:

>>> "%08d" % int(bin(6)[2:])
00000110

回答 5

..或如果不确定该数字始终为8位数字，则可以将其作为参数传递：

>>> '%0*d' % (8, int(bin(6)[2:]))
'00000110'

.. or if you’re not sure it should always be 8 digits, you can pass it as a parameter:

>>> '%0*d' % (8, int(bin(6)[2:]))
'00000110'

回答 6

上老学校总是可行的

def intoBinary(number):
binarynumber=""
if (number!=0):
    while (number>=1):
        if (number %2==0):
            binarynumber=binarynumber+"0"
            number=number/2
        else:
            binarynumber=binarynumber+"1"
            number=(number-1)/2

else:
    binarynumber="0"

return "".join(reversed(binarynumber))

Going Old School always works

def intoBinary(number):
binarynumber=""
if (number!=0):
    while (number>=1):
        if (number %2==0):
            binarynumber=binarynumber+"0"
            number=number/2
        else:
            binarynumber=binarynumber+"1"
            number=(number-1)/2

else:
    binarynumber="0"

return "".join(reversed(binarynumber))

回答 7

`numpy.binary_repr(num, width=None)` 有一个魔术宽度论点

上面链接的文档中的相关示例：

>>> np.binary_repr(3, width=4)
'0011'
当输入数字为负并且指定了宽度时，将返回二进制补码：
>>> np.binary_repr(-3, width=5)
'11101'

`numpy.binary_repr(num, width=None)` has a magic width argument

Relevant examples from the documentation linked above:

>>> np.binary_repr(3, width=4)
'0011'
The two’s complement is returned when the input number is negative and width is specified:
>>> np.binary_repr(-3, width=5)
'11101'

回答 8

('0' * 7 + bin(6)[2:])[-8:]

要么

right_side = bin(6)[2:]
'0' * ( 8 - len( right_side )) + right_side

('0' * 7 + bin(6)[2:])[-8:]

right_side = bin(6)[2:]
'0' * ( 8 - len( right_side )) + right_side

回答 9

假设您要解析用于表示不总是恒定的变量的位数，一种好方法是使用numpy.binary。

当您将二进制应用于功率集时可能会有用

import numpy as np
np.binary_repr(6, width=8)

Assuming you want to parse the number of digits used to represent from a variable which is not always constant, a good way will be to use numpy.binary.

could be useful when you apply binary to power sets

import numpy as np
np.binary_repr(6, width=8)

回答 10

甚至更简单的方法

my_num = 6
print(f'{my_num:b}')

even an easier way

my_num = 6
print(f'{my_num:b}')

回答 11

最好的方法是指定格式。

format(a, 'b')

以字符串格式返回a的二进制值。

要将二进制字符串转换回整数，请使用int（）函数。

int('110', 2)

返回二进制字符串的整数值。

The best way is to specify the format.

format(a, 'b')

returns the binary value of a in string format.

To convert a binary string back to integer, use int() function.

int('110', 2)

returns integer value of binary string.

回答 12

def int_to_bin(num, fill):
    bin_result = ''

    def int_to_binary(number):
        nonlocal bin_result
        if number > 1:
            int_to_binary(number // 2)
        bin_result = bin_result + str(number % 2)

    int_to_binary(num)
    return bin_result.zfill(fill)

def int_to_bin(num, fill):
    bin_result = ''

    def int_to_binary(number):
        nonlocal bin_result
        if number > 1:
            int_to_binary(number // 2)
        bin_result = bin_result + str(number % 2)

    int_to_binary(num)
    return bin_result.zfill(fill)

回答 13

您可以使用：

"{0:b}".format(n)

我认为这是最简单的方法！

You can use just:

"{0:b}".format(n)

In my opinion this is the easiest way!

知识问答

Python中整数的长度

2021年8月1日 Python实用宝典

问题：Python中整数的长度

在Python中，如何找到整数位数？

In Python, how do you find the number of digits in an integer?

回答 0

如果您希望整数的长度与整数的位数一样，则可以始终将其转换为string，str(133)并找到其长度，如len(str(123))。

If you want the length of an integer as in the number of digits in the integer, you can always convert it to string like str(133) and find its length like len(str(123)).

回答 1

不转换为字符串

import math
digits = int(math.log10(n))+1

同时处理零和负数

import math
if n > 0:
    digits = int(math.log10(n))+1
elif n == 0:
    digits = 1
else:
    digits = int(math.log10(-n))+2 # +1 if you don't count the '-'

您可能希望将其放入函数中：）

这是一些基准。在len(str())已经落后的甚至是相当小的数字

timeit math.log10(2**8)
1000000 loops, best of 3: 746 ns per loop
timeit len(str(2**8))
1000000 loops, best of 3: 1.1 µs per loop

timeit math.log10(2**100)
1000000 loops, best of 3: 775 ns per loop
 timeit len(str(2**100))
100000 loops, best of 3: 3.2 µs per loop

timeit math.log10(2**10000)
1000000 loops, best of 3: 844 ns per loop
timeit len(str(2**10000))
100 loops, best of 3: 10.3 ms per loop

Without conversion to string

import math
digits = int(math.log10(n))+1

To also handle zero and negative numbers

import math
if n > 0:
    digits = int(math.log10(n))+1
elif n == 0:
    digits = 1
else:
    digits = int(math.log10(-n))+2 # +1 if you don't count the '-'

You’d probably want to put that in a function :)

Here are some benchmarks. The len(str()) is already behind for even quite small numbers

timeit math.log10(2**8)
1000000 loops, best of 3: 746 ns per loop
timeit len(str(2**8))
1000000 loops, best of 3: 1.1 µs per loop

timeit math.log10(2**100)
1000000 loops, best of 3: 775 ns per loop
 timeit len(str(2**100))
100000 loops, best of 3: 3.2 µs per loop

timeit math.log10(2**10000)
1000000 loops, best of 3: 844 ns per loop
timeit len(str(2**10000))
100 loops, best of 3: 10.3 ms per loop

回答 2

所有math.log10解决方案都会给您带来问题。

math.log10速度很快，但是当您的数字大于999999999999997时会出现问题。这是因为浮点数太多.9s，导致结果四舍五入。

解决方案是对大于该阈值的数字使用while计数器方法。

为了使速度更快，请创建10 ^ 16、10 ^ 17，依此类推，并作为变量存储在列表中。这样，它就像一个表查找。

def getIntegerPlaces(theNumber):
    if theNumber <= 999999999999997:
        return int(math.log10(theNumber)) + 1
    else:
        counter = 15
        while theNumber >= 10**counter:
            counter += 1
        return counter

All math.log10 solutions will give you problems.

math.log10 is fast but gives problem when your number is greater than 999999999999997. This is because the float have too many .9s, causing the result to round up.

The solution is to use a while counter method for numbers above that threshold.

To make this even faster, create 10^16, 10^17 so on so forth and store as variables in a list. That way, it is like a table lookup.

def getIntegerPlaces(theNumber):
    if theNumber <= 999999999999997:
        return int(math.log10(theNumber)) + 1
    else:
        counter = 15
        while theNumber >= 10**counter:
            counter += 1
        return counter

回答 3

Python 2.* int占用4或8个字节（32或64位），具体取决于您的Python构建。 sys.maxint（2**31-1对于32位整数，2**63-1对于64位整数）将告诉您获得两种可能性中的哪一种。

在Python 3中，ints（类似于longPython 2中的）可以采用任意大小，直到可用内存量为止。sys.getsizeof为您提供任何给定值一个很好的迹象，但它确实也算一些固定开销：

>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28

如果，正如其他答案所暗示的那样，如果您正在考虑某个整数值的字符串表示形式，则只需采用该len表示形式的形式即可，无论是以10还是10为底！

Python 2.* ints take either 4 or 8 bytes (32 or 64 bits), depending on your Python build. sys.maxint (2**31-1 for 32-bit ints, 2**63-1 for 64-bit ints) will tell you which of the two possibilities obtains.

In Python 3, ints (like longs in Python 2) can take arbitrary sizes up to the amount of available memory; sys.getsizeof gives you a good indication for any given value, although it does also count some fixed overhead:

>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28

If, as other answers suggests, you’re thinking about some string representation of the integer value, then just take the len of that representation, be it in base 10 or otherwise!

回答 4

自问这个问题以来已经有好几年了，但是我已经为几种计算整数长度的方法编制了基准。

def libc_size(i): 
    return libc.snprintf(buf, 100, c_char_p(b'%i'), i) # equivalent to `return snprintf(buf, 100, "%i", i);`

def str_size(i):
    return len(str(i)) # Length of `i` as a string

def math_size(i):
    return 1 + math.floor(math.log10(i)) # 1 + floor of log10 of i

def exp_size(i):
    return int("{:.5e}".format(i).split("e")[1]) + 1 # e.g. `1e10` -> `10` + 1 -> 11

def mod_size(i):
    return len("%i" % i) # Uses string modulo instead of str(i)

def fmt_size(i):
    return len("{0}".format(i)) # Same as above but str.format

（libc函数需要一些设置，我没有包括在内）

size_exp感谢Brian Preslopsky，size_str感谢GeekTantra，以及size_math John La Rooy

结果如下：

Time for libc size:      1.2204 μs
Time for string size:    309.41 ns
Time for math size:      329.54 ns
Time for exp size:       1.4902 μs
Time for mod size:       249.36 ns
Time for fmt size:       336.63 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.240835x)
+ math_size (1.321577x)
+ fmt_size (1.350007x)
+ libc_size (4.894290x)
+ exp_size (5.976219x)

（免责声明：该函数在输入1到1,000,000上运行）

下面是结果sys.maxsize - 100000到sys.maxsize：

Time for libc size:      1.4686 μs
Time for string size:    395.76 ns
Time for math size:      485.94 ns
Time for exp size:       1.6826 μs
Time for mod size:       364.25 ns
Time for fmt size:       453.06 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.086498x)
+ fmt_size (1.243817x)
+ math_size (1.334066x)
+ libc_size (4.031780x)
+ exp_size (4.619188x)

如您所见，mod_size（len("%i" % i)）是最快的，比使用速度稍快，str(i)并且比其他速度快得多。

It’s been several years since this question was asked, but I have compiled a benchmark of several methods to calculate the length of an integer.

def libc_size(i): 
    return libc.snprintf(buf, 100, c_char_p(b'%i'), i) # equivalent to `return snprintf(buf, 100, "%i", i);`

def str_size(i):
    return len(str(i)) # Length of `i` as a string

def math_size(i):
    return 1 + math.floor(math.log10(i)) # 1 + floor of log10 of i

def exp_size(i):
    return int("{:.5e}".format(i).split("e")[1]) + 1 # e.g. `1e10` -> `10` + 1 -> 11

def mod_size(i):
    return len("%i" % i) # Uses string modulo instead of str(i)

def fmt_size(i):
    return len("{0}".format(i)) # Same as above but str.format

(the libc function requires some setup, which I haven’t included)

size_exp is thanks to Brian Preslopsky, size_str is thanks to GeekTantra, and size_math is thanks to John La Rooy

Here are the results:

Time for libc size:      1.2204 μs
Time for string size:    309.41 ns
Time for math size:      329.54 ns
Time for exp size:       1.4902 μs
Time for mod size:       249.36 ns
Time for fmt size:       336.63 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.240835x)
+ math_size (1.321577x)
+ fmt_size (1.350007x)
+ libc_size (4.894290x)
+ exp_size (5.976219x)

(Disclaimer: the function is run on inputs 1 to 1,000,000)

Here are the results for sys.maxsize - 100000 to sys.maxsize:

Time for libc size:      1.4686 μs
Time for string size:    395.76 ns
Time for math size:      485.94 ns
Time for exp size:       1.6826 μs
Time for mod size:       364.25 ns
Time for fmt size:       453.06 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.086498x)
+ fmt_size (1.243817x)
+ math_size (1.334066x)
+ libc_size (4.031780x)
+ exp_size (4.619188x)

As you can see, mod_size (len("%i" % i)) is the fastest, slightly faster than using str(i) and significantly faster than others.

回答 5

设数字为，n则数字的位数n为：

math.floor(math.log10(n))+1

请注意，这将为+ ve整数<10e15给出正确的答案。除此之外，返回类型的精度限制math.log10和答案可能会相差1 len(str(n))。这需要的O(log(n))时间与对10的幂进行迭代相同。

感谢@SetiVolkylany将我的注意力带到了这个限制上。看起来正确的解决方案在实现细节上有一些警告，这令人惊讶。

Let the number be n then the number of digits in n is given by:

math.floor(math.log10(n))+1

Note that this will give correct answers for +ve integers < 10e15. Beyond that the precision limits of the return type of math.log10 kicks in and the answer may be off by 1. I would simply use len(str(n)) beyond that; this requires O(log(n)) time which is same as iterating over powers of 10.

Thanks to @SetiVolkylany for bringing my attenstion to this limitation. Its amazing how seemingly correct solutions have caveats in implementation details.

回答 6

好吧，如果不转换为字符串，我将执行以下操作：

def lenDigits(x): 
    """
    Assumes int(x)
    """

    x = abs(x)

    if x < 10:
        return 1

    return 1 + lenDigits(x / 10)

极简递归FTW

Well, without converting to string I would do something like:

def lenDigits(x): 
    """
    Assumes int(x)
    """

    x = abs(x)

    if x < 10:
        return 1

    return 1 + lenDigits(x / 10)

Minimalist recursion FTW

回答 7

计算不将整数转换为字符串的位数：

x=123
x=abs(x)
i = 0
while x >= 10**i:
    i +=1
# i is the number of digits

Count the number of digits w/o convert integer to a string:

x=123
x=abs(x)
i = 0
while x >= 10**i:
    i +=1
# i is the number of digits

回答 8

如亲爱的用户@Calvintwr所提到的，该函数math.log10在范围[-999999999999997，999999999999997]之外的数字中存在问题，在此我们会出现浮点错误。我在JavaScript（Google V8和NodeJS）和C（GNU GCC编译器）上遇到了这个问题，因此'purely mathematically'这里没有解决方案。

基于这个要点和答案，亲爱的用户@Calvintwr

import math


def get_count_digits(number: int):
    """Return number of digits in a number."""

    if number == 0:
        return 1

    number = abs(number)

    if number <= 999999999999997:
        return math.floor(math.log10(number)) + 1

    count = 0
    while number:
        count += 1
        number //= 10
    return count

我测试了长度不超过20（含）的数字，还好。这必须足够，因为在64位系统上，最大长度为整数（19 len(str(sys.maxsize)) == 19）。

assert get_count_digits(-99999999999999999999) == 20
assert get_count_digits(-10000000000000000000) == 20
assert get_count_digits(-9999999999999999999) == 19
assert get_count_digits(-1000000000000000000) == 19
assert get_count_digits(-999999999999999999) == 18
assert get_count_digits(-100000000000000000) == 18
assert get_count_digits(-99999999999999999) == 17
assert get_count_digits(-10000000000000000) == 17
assert get_count_digits(-9999999999999999) == 16
assert get_count_digits(-1000000000000000) == 16
assert get_count_digits(-999999999999999) == 15
assert get_count_digits(-100000000000000) == 15
assert get_count_digits(-99999999999999) == 14
assert get_count_digits(-10000000000000) == 14
assert get_count_digits(-9999999999999) == 13
assert get_count_digits(-1000000000000) == 13
assert get_count_digits(-999999999999) == 12
assert get_count_digits(-100000000000) == 12
assert get_count_digits(-99999999999) == 11
assert get_count_digits(-10000000000) == 11
assert get_count_digits(-9999999999) == 10
assert get_count_digits(-1000000000) == 10
assert get_count_digits(-999999999) == 9
assert get_count_digits(-100000000) == 9
assert get_count_digits(-99999999) == 8
assert get_count_digits(-10000000) == 8
assert get_count_digits(-9999999) == 7
assert get_count_digits(-1000000) == 7
assert get_count_digits(-999999) == 6
assert get_count_digits(-100000) == 6
assert get_count_digits(-99999) == 5
assert get_count_digits(-10000) == 5
assert get_count_digits(-9999) == 4
assert get_count_digits(-1000) == 4
assert get_count_digits(-999) == 3
assert get_count_digits(-100) == 3
assert get_count_digits(-99) == 2
assert get_count_digits(-10) == 2
assert get_count_digits(-9) == 1
assert get_count_digits(-1) == 1
assert get_count_digits(0) == 1
assert get_count_digits(1) == 1
assert get_count_digits(9) == 1
assert get_count_digits(10) == 2
assert get_count_digits(99) == 2
assert get_count_digits(100) == 3
assert get_count_digits(999) == 3
assert get_count_digits(1000) == 4
assert get_count_digits(9999) == 4
assert get_count_digits(10000) == 5
assert get_count_digits(99999) == 5
assert get_count_digits(100000) == 6
assert get_count_digits(999999) == 6
assert get_count_digits(1000000) == 7
assert get_count_digits(9999999) == 7
assert get_count_digits(10000000) == 8
assert get_count_digits(99999999) == 8
assert get_count_digits(100000000) == 9
assert get_count_digits(999999999) == 9
assert get_count_digits(1000000000) == 10
assert get_count_digits(9999999999) == 10
assert get_count_digits(10000000000) == 11
assert get_count_digits(99999999999) == 11
assert get_count_digits(100000000000) == 12
assert get_count_digits(999999999999) == 12
assert get_count_digits(1000000000000) == 13
assert get_count_digits(9999999999999) == 13
assert get_count_digits(10000000000000) == 14
assert get_count_digits(99999999999999) == 14
assert get_count_digits(100000000000000) == 15
assert get_count_digits(999999999999999) == 15
assert get_count_digits(1000000000000000) == 16
assert get_count_digits(9999999999999999) == 16
assert get_count_digits(10000000000000000) == 17
assert get_count_digits(99999999999999999) == 17
assert get_count_digits(100000000000000000) == 18
assert get_count_digits(999999999999999999) == 18
assert get_count_digits(1000000000000000000) == 19
assert get_count_digits(9999999999999999999) == 19
assert get_count_digits(10000000000000000000) == 20
assert get_count_digits(99999999999999999999) == 20

使用Python 3.5测试的所有代码示例

As mentioned the dear user @Calvintwr, the function math.log10 has problem in a number outside of a range [-999999999999997, 999999999999997], where we get floating point errors. I had this problem with the JavaScript (the Google V8 and the NodeJS) and the C (the GNU GCC compiler), so a 'purely mathematically' solution is impossible here.

Based on this gist and the answer the dear user @Calvintwr

import math


def get_count_digits(number: int):
    """Return number of digits in a number."""

    if number == 0:
        return 1

    number = abs(number)

    if number <= 999999999999997:
        return math.floor(math.log10(number)) + 1

    count = 0
    while number:
        count += 1
        number //= 10
    return count

I tested it on numbers with length up to 20 (inclusive) and all right. It must be enough, because the length max integer number on a 64-bit system is 19 (len(str(sys.maxsize)) == 19).

assert get_count_digits(-99999999999999999999) == 20
assert get_count_digits(-10000000000000000000) == 20
assert get_count_digits(-9999999999999999999) == 19
assert get_count_digits(-1000000000000000000) == 19
assert get_count_digits(-999999999999999999) == 18
assert get_count_digits(-100000000000000000) == 18
assert get_count_digits(-99999999999999999) == 17
assert get_count_digits(-10000000000000000) == 17
assert get_count_digits(-9999999999999999) == 16
assert get_count_digits(-1000000000000000) == 16
assert get_count_digits(-999999999999999) == 15
assert get_count_digits(-100000000000000) == 15
assert get_count_digits(-99999999999999) == 14
assert get_count_digits(-10000000000000) == 14
assert get_count_digits(-9999999999999) == 13
assert get_count_digits(-1000000000000) == 13
assert get_count_digits(-999999999999) == 12
assert get_count_digits(-100000000000) == 12
assert get_count_digits(-99999999999) == 11
assert get_count_digits(-10000000000) == 11
assert get_count_digits(-9999999999) == 10
assert get_count_digits(-1000000000) == 10
assert get_count_digits(-999999999) == 9
assert get_count_digits(-100000000) == 9
assert get_count_digits(-99999999) == 8
assert get_count_digits(-10000000) == 8
assert get_count_digits(-9999999) == 7
assert get_count_digits(-1000000) == 7
assert get_count_digits(-999999) == 6
assert get_count_digits(-100000) == 6
assert get_count_digits(-99999) == 5
assert get_count_digits(-10000) == 5
assert get_count_digits(-9999) == 4
assert get_count_digits(-1000) == 4
assert get_count_digits(-999) == 3
assert get_count_digits(-100) == 3
assert get_count_digits(-99) == 2
assert get_count_digits(-10) == 2
assert get_count_digits(-9) == 1
assert get_count_digits(-1) == 1
assert get_count_digits(0) == 1
assert get_count_digits(1) == 1
assert get_count_digits(9) == 1
assert get_count_digits(10) == 2
assert get_count_digits(99) == 2
assert get_count_digits(100) == 3
assert get_count_digits(999) == 3
assert get_count_digits(1000) == 4
assert get_count_digits(9999) == 4
assert get_count_digits(10000) == 5
assert get_count_digits(99999) == 5
assert get_count_digits(100000) == 6
assert get_count_digits(999999) == 6
assert get_count_digits(1000000) == 7
assert get_count_digits(9999999) == 7
assert get_count_digits(10000000) == 8
assert get_count_digits(99999999) == 8
assert get_count_digits(100000000) == 9
assert get_count_digits(999999999) == 9
assert get_count_digits(1000000000) == 10
assert get_count_digits(9999999999) == 10
assert get_count_digits(10000000000) == 11
assert get_count_digits(99999999999) == 11
assert get_count_digits(100000000000) == 12
assert get_count_digits(999999999999) == 12
assert get_count_digits(1000000000000) == 13
assert get_count_digits(9999999999999) == 13
assert get_count_digits(10000000000000) == 14
assert get_count_digits(99999999999999) == 14
assert get_count_digits(100000000000000) == 15
assert get_count_digits(999999999999999) == 15
assert get_count_digits(1000000000000000) == 16
assert get_count_digits(9999999999999999) == 16
assert get_count_digits(10000000000000000) == 17
assert get_count_digits(99999999999999999) == 17
assert get_count_digits(100000000000000000) == 18
assert get_count_digits(999999999999999999) == 18
assert get_count_digits(1000000000000000000) == 19
assert get_count_digits(9999999999999999999) == 19
assert get_count_digits(10000000000000000000) == 20
assert get_count_digits(99999999999999999999) == 20

All example of codes tested with the Python 3.5

回答 9

对于后代来说，毫无疑问，这是迄今为止最慢的解决方案：

def num_digits(num, number_of_calls=1):
    "Returns the number of digits of an integer num."
    if num == 0 or num == -1:
        return 1 if number_of_calls == 1 else 0
    else:
        return 1 + num_digits(num/10, number_of_calls+1)

For posterity, no doubt by far the slowest solution to this problem:

def num_digits(num, number_of_calls=1):
    "Returns the number of digits of an integer num."
    if num == 0 or num == -1:
        return 1 if number_of_calls == 1 else 0
    else:
        return 1 + num_digits(num/10, number_of_calls+1)

回答 10

from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1

from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1

回答 11

假设您要求存储的最大数字整数，则该值取决于实现。我建议您在使用python时不要以这种方式思考。无论如何，可以在python’integer’中存储很大的值。记住，Python使用鸭子类型！

编辑： 我在澄清询问者要求数字位数之前给出了答案。为此，我同意接受的答案所建议的方法。没有什么可添加的！

Assuming you are asking for the largest number you can store in an integer, the value is implementation dependent. I suggest that you don’t think in that way when using python. In any case, quite a large value can be stored in a python ‘integer’. Remember, Python uses duck typing!

Edit: I gave my answer before the clarification that the asker wanted the number of digits. For that, I agree with the method suggested by the accepted answer. Nothing more to add!

回答 12

def length(i):
  return len(str(i))

def length(i):
  return len(str(i))

回答 13

可以使用以下方法快速完成整数操作：

len(str(abs(1234567890)))

它获取绝对值“ 1234567890”的字符串的长度

abs返回没有任何负数的数字（仅数字的大小），str将其转换/转换为字符串，并len返回该字符串的字符串长度。

如果您希望它适用于浮点数，则可以使用以下两种方法之一：

# Ignore all after decimal place
len(str(abs(0.1234567890)).split(".")[0])

# Ignore just the decimal place
len(str(abs(0.1234567890)))-1

备查。

It can be done for integers quickly by using:

len(str(abs(1234567890)))

Which gets the length of the string of the absolute value of “1234567890”

abs returns the number WITHOUT any negatives (only the magnitude of the number), str casts/converts it to a string and len returns the string length of that string.

If you want it to work for floats, you can use either of the following:

# Ignore all after decimal place
len(str(abs(0.1234567890)).split(".")[0])

# Ignore just the decimal place
len(str(abs(0.1234567890)))-1

For future reference.

回答 14

以科学记数法表示格式并得出指数：

int("{:.5e}".format(1000000).split("e")[1]) + 1

我不知道速度，但这很简单。

请注意，小数点后的有效位数（如果将科学计数的小数部分四舍五入到另一个数字，则“ .5e”中的“ 5”可能是一个问题。我将其设置为任意大，但可以反映您知道的最大数字的长度。

Format in scientific notation and pluck off the exponent:

int("{:.5e}".format(1000000).split("e")[1]) + 1

I don’t know about speed, but it’s simple.

Please note the number of significant digits after the decimal (the “5” in the “.5e” can be an issue if it rounds up the decimal part of the scientific notation to another digit. I set it arbitrarily large, but could reflect the length of the largest number you know about.

回答 15

def count_digit(number):
  if number >= 10:
    count = 2
  else:
    count = 1
  while number//10 > 9:
    count += 1
    number = number//10
  return count

def count_digit(number):
  if number >= 10:
    count = 2
  else:
    count = 1
  while number//10 > 9:
    count += 1
    number = number//10
  return count

回答 16

如果必须要求用户输入内容，然后必须计算有多少个数字，则可以按照以下步骤操作：

count_number = input('Please enter a number\t')

print(len(count_number))

注意：切勿将int用作用户输入。

If you have to ask an user to give input and then you have to count how many numbers are there then you can follow this:

count_number = input('Please enter a number\t')

print(len(count_number))

Note: Never take an int as user input.

回答 17

def digits(n)
    count = 0
    if n == 0:
        return 1
    while (n >= 10**count):
        count += 1
        n += n%10
    return count
print(digits(25))   # Should print 2
print(digits(144))  # Should print 3
print(digits(1000)) # Should print 4
print(digits(0))    # Should print 1

def digits(n)
    count = 0
    if n == 0:
        return 1
    
    if n < 0:
        n *= -1

    while (n >= 10**count):
        count += 1
        n += n%10

    return count

print(digits(25))   # Should print 2
print(digits(144))  # Should print 3
print(digits(1000)) # Should print 4
print(digits(0))    # Should print 1

回答 18

我的代码与此相同；我使用了log10方法：

from math import *

def digit_count（数字）：

if number>1 and round(log10(number))>=log10(number) and number%10!=0 :
    return round(log10(number))
elif  number>1 and round(log10(number))<log10(number) and number%10!=0:
    return round(log10(number))+1
elif number%10==0 and number!=0:
    return int(log10(number)+1)
elif number==1 or number==0:
    return 1

我必须指定1和0的情况，因为log10（1）= 0和log10（0）= ND，因此不满足提到的条件。但是，此代码仅适用于整数。

My code for the same is as follows;i have used the log10 method:

from math import *

def digit_count(number):

if number>1 and round(log10(number))>=log10(number) and number%10!=0 :
    return round(log10(number))
elif  number>1 and round(log10(number))<log10(number) and number%10!=0:
    return round(log10(number))+1
elif number%10==0 and number!=0:
    return int(log10(number)+1)
elif number==1 or number==0:
    return 1

I had to specify in case of 1 and 0 because log10(1)=0 and log10(0)=ND and hence the condition mentioned isn’t satisfied. However, this code works only for whole numbers.

回答 19

这是一个笨重但快速的版本：

def nbdigit ( x ):
    if x >= 10000000000000000 : # 17 -
        return len( str( x ))
    if x < 100000000 : # 1 - 8
        if x < 10000 : # 1 - 4
            if x < 100             : return (x >= 10)+1 
            else                   : return (x >= 1000)+3
        else: # 5 - 8                                                 
            if x < 1000000         : return (x >= 100000)+5 
            else                   : return (x >= 10000000)+7
    else: # 9 - 16 
        if x < 1000000000000 : # 9 - 12
            if x < 10000000000     : return (x >= 1000000000)+9 
            else                   : return (x >= 100000000000)+11
        else: # 13 - 16
            if x < 100000000000000 : return (x >= 10000000000000)+13 
            else                   : return (x >= 1000000000000000)+15

对于不太大的数字，只有5个比较。在我的计算机上，它比该math.log10版本快30％，比该版本快5％len( str())。好吧…如果您不疯狂使用它，那么没有吸引力。

这是我用来测试/测量功能的一组数字：

n = [ int( (i+1)**( 17/7. )) for i in xrange( 1000000 )] + [0,10**16-1,10**16,10**16+1]

注意：它不管理负数，但适应很容易…

Here is a bulky but fast version :

def nbdigit ( x ):
    if x >= 10000000000000000 : # 17 -
        return len( str( x ))
    if x < 100000000 : # 1 - 8
        if x < 10000 : # 1 - 4
            if x < 100             : return (x >= 10)+1 
            else                   : return (x >= 1000)+3
        else: # 5 - 8                                                 
            if x < 1000000         : return (x >= 100000)+5 
            else                   : return (x >= 10000000)+7
    else: # 9 - 16 
        if x < 1000000000000 : # 9 - 12
            if x < 10000000000     : return (x >= 1000000000)+9 
            else                   : return (x >= 100000000000)+11
        else: # 13 - 16
            if x < 100000000000000 : return (x >= 10000000000000)+13 
            else                   : return (x >= 1000000000000000)+15

Only 5 comparisons for not too big numbers. On my computer it is about 30% faster than the math.log10 version and 5% faster than the len( str()) one. Ok… no so attractive if you don’t use it furiously.

And here is the set of numbers I used to test/measure my function:

n = [ int( (i+1)**( 17/7. )) for i in xrange( 1000000 )] + [0,10**16-1,10**16,10**16+1]

NB: it does not manage negative numbers, but the adaptation is easy…

回答 20

>>> a=12345
>>> a.__str__().__len__()
5

>>> a=12345
>>> a.__str__().__len__()
5

问题：将int转换为ASCII并返回Python

回答 0

回答 1

回答 2

回答 3

回答 4

问题：如何将布尔数组转换为int数组

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

问题：将浮点数向下舍入到最接近的整数？

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

回答 6

回答 7

回答 8

回答 9

回答 10

回答 11

问题：Python如何管理int和long？

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

回答 6

回答 7

回答 8

问题：为什么Python 3允许“ 00”作为0的文字，却不允许“ 01”作为1的文字？

回答 0

回答 1

回答 2

问题：从整数列表中，获取最接近给定值的数字

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

回答 6

回答 7

问题：Python整数除法产生浮点数

回答 0

回答 1

回答 2

Python 2.7和Python 3中除法运算符的行为

Behavior of Division Operator in Python 2.7 and Python 3

回答 3

回答 4

问题：在Python中将float转换为整数的最安全方法？

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

回答 6

回答 7

回答 8

回答 9

问题：在python中将整数转换为二进制

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

回答 6

回答 7

numpy.binary_repr(num, width=None) 有一个魔术宽度论点

numpy.binary_repr(num, width=None) has a magic width argument

回答 8

`numpy.binary_repr(num, width=None)` 有一个魔术宽度论点

`numpy.binary_repr(num, width=None)` has a magic width argument