百分比符号在 Python 中的意思是什么

在本教程中有一个寻找素数的例子:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...

我知道双 ==是一个相等的测试，但是我不明白 if n % x部分。比如我可以口头浏览每个部分，并说明语句为示例所做的工作。但我不明白百分比符号是怎么进来的。

if n % x实际上说了什么？

295974 次浏览
小开

在 python2.6中，“%”运算符执行了一个模数

模运算符告诉你两个数除法的余数。

小开
最佳答案

模运算符; 给出左边值除以右边值的余数。如:

3 % 1等于零(因为3除以1是均匀的)

3 % 2等于1(因为3除以2的结果是1的余数)。

小开

它检查除法的模数。例如，在这种情况下，您将遍历从2到 n 的所有数字，并检查 n 是否可以被中间的任何数字整除。简单地说，您要检查给定的数字 n 是否为素数。(提示: 您可以检查到 n/2)。

小开

根据参数的不同,% 可以做两件事。在这种情况下，它充当模运算符，这意味着当它的参数是数字时，它将第一个除以第二个，并返回 余额。34 % 10 == 4由34除以10等于3，余数为4。

如果第一个参数是字符串，则使用第二个参数对其进行格式化。这有点复杂，所以我将参考 文件，但只是作为一个例子:

>>> "foo %d bar" % 5
'foo 5 bar'

然而，字符串格式化行为在 Python 3.1中得到了补充，有利于 绳子.format()机制:

这里描述的格式化操作展示了导致许多常见错误(例如未能正确显示元组和字典)的各种异常。使用较新的 str.format()接口有助于避免这些错误，并且还提供了一种通常更强大、更灵活和可扩展的文本格式化方法。

谢天谢地，几乎所有的新特性都可以从 python 2.6开始使用。

小开

模运算符，除以两个数的余数。

例如:

>>> 5 % 2 = 1 # remainder of 5 divided by 2 is 1
>>> 7 % 3 = 1 # remainer of 7 divided by 3 is 1
>>> 3 % 1 = 0 # because 1 divides evenly into 3
小开

虽然这有点偏离主题，因为人们会通过搜索“ Python 中的百分比符号”(就像我一样)来找到它，但我想指出的是，在 iPython: https://ipython.org/ipython-doc/3/interactive/tutorial.html#magic-functions中,% 符号也被用来作为“ magic”函数的前缀

小开

X% n = = 0
这意味着 x/n 和提醒值将作为结果，并与零进行比较。

例如: 4/5 = 0

4/5提醒是4

4 = = 0(False)

小开

百分比符号是什么意思？

它是 Python 中的一个操作符，根据上下文的不同，它可以有多种含义。下面的许多内容已经在其他答案中提到(或暗示) ，但我认为提供一个更广泛的总结会有所帮助。

数字: 模除/剩余/休息

百分比符号是 Python 中的运算符，它被描述为:

x % y       remainder of x / y

因此，如果你用 y 除以 x，它会给出 余下/休息 仍然存在。一般来说(至少在 Python 中) ，给定一个数字 x和一个除数 y:

x == y * (x // y) + (x % y)

例如，如果你把5除以2:

>>> 5 // 2
2
>>> 5 % 2
1


>>> 2 * (5 // 2) + (5 % 2)
5

一般来说，你用模除来测试一个数字是否被另一个数字平均除，这是因为这个数字的模的倍数返回0:

>>> 15 % 5  # 15 is 3 * 5
0


>>> 81 % 9  # 81 is 9 * 9
0

这就是它在你的例子中的用法，如果它是另一个数的倍数(除了它自己和一) ，它就不能是一个质数，这就是它的作用:

if n % x == 0:
break

如果你觉得 n % x == 0不是很具有描述性，你可以把它放到另一个更具描述性的函数中:

def is_multiple(number, divisor):
return number % divisor == 0


...


if is_multiple(n, x):
break

它也可以被命名为 evenly_divides或类似的名字，这就是我们在这里测试的内容。

类似的，它经常被用来确定一个数字是“奇数”还是“偶数”:

def is_odd(number):
return number % 2 == 1


def is_even(number):
return number % 2 == 0

在某些情况下，当需要环绕(循环)行为时，它还可以用于数组/列表索引，然后只需将“索引”模块化为“数组的长度”即可:

>>> l = [0, 1, 2]
>>> length = len(l)
>>> for index in range(10):
...     print(l[index % length])
0
1
2
0
1
2
0
1
2
0

注意，在标准库 operator.mod(以及别名 operator.__mod__)中也有一个针对这个操作符的函数:

>>> import operator
>>> operator.mod(5, 2)  # equivalent to 5 % 2
1

但是还有一个增量赋值 %=，它把结果赋回给变量:

>>> a = 5
>>> a %= 2  # identical to: a = a % 2
>>> a
1

字符串 %: printf样式的字符串格式设置

对于字符串来说，它的含义是完全不同的，有 单行道(在我看来是最有限和最丑陋的)来进行字符串格式化:

>>> "%s is %s." % ("this", "good")
'this is good'

在这里，字符串中的 %表示一个占位符，后跟一个格式规范。在本例中，我使用了 %s，这意味着它需要一个字符串。然后字符串后面跟一个 %，表示左边的字符串将由右边格式化。在这种情况下，第一个 %s被第一个参数 this替换，第二个 %s被第二个参数(good)替换。

注意，有更好的(可能是基于意见的)格式化字符串的方法:

>>> "{} is {}.".format("this", "good")
'this is good.'

Jupyter 的 %/IPython: 魔法命令

引用 医生的话:

对于 Jupiter 用户: Magics 是 IPython 内核特有的，并由 IPython 内核提供。魔法是否在内核上可用是由内核开发人员根据每个内核的情况做出的决定。为了正常工作，Magics 必须使用在基础语言中无效的语法元素。例如，IPython 内核使用 %语法元素进行魔法，因为 %在 Python 中不是有效的一元运算符。而语法元素在其他语言中也有意义。

这在 Jupyter 的笔记本电脑和类似产品中经常使用:

In [1]:  a = 10
b = 20
%timeit a + b   # one % -> line-magic


54.6 ns ± 2.7 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)


In [2]:  %%timeit  # two %% -> cell magic
a ** b


362 ns ± 8.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

数组上的 %操作符(在 NumPy/Panda 生态系统中)

当应用到这些数组时，%运算符仍然是模运算符，但它返回一个包含数组中每个元素剩余部分的数组:

>>> import numpy as np
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])


>>> a % 2
array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])

为您自己的类自定义 %运算符

当然，您可以定制自己的类在应用 %运算符时的工作方式。一般你 应该只用它来实现模操作！但这只是指导方针，不是硬性规定。

只是提供一个简单的例子来说明它是如何工作的:

class MyNumber(object):
def __init__(self, value):
self.value = value


def __mod__(self, other):
print("__mod__ called on '{!r}'".format(self))
return self.value % other


def __repr__(self):
return "{self.__class__.__name__}({self.value!r})".format(self=self)

这个例子并不是真正有用，它只是打印出操作符，然后将其委托给存储的值，但是它显示了当 %应用到一个实例时，__mod__被调用:

>>> a = MyNumber(10)
>>> a % 2
__mod__ called on 'MyNumber(10)'
0

请注意，它也适用于 %=，而不需要明确实现 __imod__:

>>> a = MyNumber(10)
>>> a %= 2
__mod__ called on 'MyNumber(10)'


>>> a
0

然而，您也可以显式地实现 __imod__来覆盖增强的赋值:

class MyNumber(object):
def __init__(self, value):
self.value = value


def __mod__(self, other):
print("__mod__ called on '{!r}'".format(self))
return self.value % other


def __imod__(self, other):
print("__imod__ called on '{!r}'".format(self))
self.value %= other
return self


def __repr__(self):
return "{self.__class__.__name__}({self.value!r})".format(self=self)

现在，%=已经被明确地覆盖，可以就地工作:

>>> a = MyNumber(10)
>>> a %= 2
__imod__ called on 'MyNumber(10)'


>>> a
MyNumber(0)

提交答案