Что означает процент означает знак в Python

% делает две вещи, в зависимости от его аргументов. В этом случае он действует как оператор по модулю, то есть, когда его аргументы являются числами, он делит первый на второй и возвращает остаток. 34 % 10 == 4 так как 34 делится на 10-это три, а остальные четыре.

если первый аргумент является строкой, он форматирует его, используя второй аргумент. Это немного связано, поэтому я буду ссылаться на документация, но только в качестве примера:

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

однако поведение форматирования строк дополняется с Python 3.1 в пользу строка.format() механизм:

операции форматирования, описанные здесь, демонстрируют различные причуды, которые приводят к ряду распространенных ошибок (таких как неправильное отображение кортежей и словарей). Использование нового str.format() интерфейс помогает избежать этих ошибок, а также обеспечивает в целом более мощный, гибкий и расширяемый подход к форматированию текста.

и, к счастью, почти все новые функции также доступны с python 2.6 и далее.

хотя это немного не по теме, так как люди найдут это, ища " процентный знак в Python "(как и я), я хотел отметить, что знак % также используется для префикса" волшебной " функции в iPython:https://ipython.org/ipython-doc/3/interactive/tutorial.html#magic-functions

что означает знак процента означает?

это оператор в Python, который может означать несколько вещей в зависимости от контекста. Многое из того, что следует ниже, уже упоминалось (или намекалось) в других ответах, но я подумал, что было бы полезно предоставить более подробное резюме.

% для чисел: операция по модулю / остаток / отдых

знак процента -оператор в Python. Это описано as:

x % y       remainder of x / y

таким образом, он дает вам остаток/остаток, что остается если вы "разделяете пол" x на y. Обычно (по крайней мере, в 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

вместо is_multiple он также может быть назван 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.'

% in Jupyter / IPython: магические команды

цитировать docs:

для пользователей Jupyter: магия специфична и предоставляется ядром IPython. Доступны ли магии в ядре-это решение, которое принимается разработчиком ядра на основе каждого ядра. Чтобы правильно работать, магия должна использовать синтаксический элемент, который недопустим в базовом языке. Например, ядро 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 / Pandas)

на % оператор по-прежнему является оператором по модулю при применении к этим массивам, но он возвращает массив, содержащий остаток каждого элемента в массив:

>>> 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)

в python 2.6 оператор " % "выполнил модуль. Я не думаю, что они изменили его в 3.0.1

оператор по модулю сообщает вам остаток деления двух чисел.

Он проверяет, если по модулю деления. Например, в случае, если вы перебираете все числа от 2 до n и проверить, если N делится на любое из чисел между ними. Проще говоря, вы проверяете, является ли данное число n простым. (Подсказка: вы можете проверить до n/2).

оператор модуля. Остальное при делении на два числа.

Например:

>>> 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

Blockquote x % n ==0 это означает, что x / n и значение напоминания будут взяты в результате и сравниваться с нулем....

пример: 4/5==0

4/5 напоминание 1

1==0 (False)