Dấu phần trăm trong python

Dấu hiệu phần trăm có ý nghĩa gì?

Đó là một toán tử trong Python có thể có nghĩa là một số thứ tùy thuộc vào ngữ cảnh. Rất nhiều điều sau đây đã được đề cập [hoặc gợi ý] trong các câu trả lời khác nhưng tôi nghĩ nó có thể hữu ích để cung cấp một bản tóm tắt sâu rộng hơn.

% cho các số: Hoạt động Modulo/Phần còn lại/Phần còn lại

Dấu phần trăm là một toán tử trong Python . Nó được mô tả là:

x % y       remainder of x / y

Vì vậy, nó cung cấp cho bạn phần còn lại/phần còn lạivẫn nếu bạn "chia sàn" x cho y. Nói chung [ít nhất là bằng Python] đã cho một số x và một ước số y:

x == y * [x // y] + [x % y]

Ví dụ: nếu bạn chia 5 cho 2:

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

>>> 2 * [5 // 2] + [5 % 2]
5

Nói chung, bạn sử dụng phép toán modulo để kiểm tra xem một số có chia đều cho một số khác không, đó là vì bội số của một số modulo mà số đó trả về 0:

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

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

Đó là cách nó được sử dụng trong ví dụ của bạn, nó không thể là số nguyên tố nếu nó là bội số của một số khác [ngoại trừ chính nó và một], đó là những gì nó làm:

if n % x == 0:
    break

Nếu bạn cảm thấy rằng n % x == 0 không mang tính mô tả, bạn có thể đặt nó ở một chức năng khác với tên mô tả hơn:

def is_multiple[number, divisor]:
    return number % divisor == 0

...

if is_multiple[n, x]:
    break

Thay vì is_multiple, nó cũng có thể được đặt tên evenly_divides hoặc một cái gì đó tương tự. Đó là những gì được thử nghiệm ở đây.

Tương tự như vậy, nó thường được sử dụng để xác định xem một số là "lẻ" hay "chẵn":

def is_odd[number]:
    return number % 2 == 1

def is_even[number]:
    return number % 2 == 0

Và trong một số trường hợp, nó cũng được sử dụng để lập chỉ mục mảng/danh sách khi muốn hành vi quấn quanh [đi xe đạp], sau đó bạn chỉ cần điều chỉnh "chỉ mục" theo "độ dài của mảng" để đạt được điều đó:

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

Lưu ý rằng cũng có một hàm cho toán tử này trong thư viện chuẩn operator.mod [và bí danh operator.__mod__ ]:

>>> import operator
>>> operator.mod[5, 2]  # equivalent to 5 % 2
1

Nhưng cũng có phép gán tăng %= gán kết quả trở lại cho biến:

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

% cho chuỗi: printf- Định dạng chuỗi kiểu

Đối với các chuỗi, ý nghĩa hoàn toàn khác nhau, đó là một cách [theo tôi là hạn chế và xấu nhất] để thực hiện định dạng chuỗi:

>>> "%s is %s." % ["this", "good"] 
'this is good'

Ở đây, % trong chuỗi đại diện cho một trình giữ chỗ theo sau là một đặc tả định dạng. Trong trường hợp này, tôi đã sử dụng %s có nghĩa là nó mong đợi một chuỗi. Sau đó, chuỗi được theo sau bởi một % chỉ ra rằng chuỗi ở phía bên trái sẽ được định dạng bởi phía bên phải. Trong trường hợp này, %s đầu tiên được thay thế bằng đối số thứ nhất this và %s thứ hai được thay thế bằng đối số thứ hai [good].

Lưu ý rằng có nhiều cách tốt hơn [có thể dựa trên quan điểm] để định dạng chuỗi:

>>> "{} is {}.".format["this", "good"]
'this is good.'

% trong Jupyter/IPython: lệnh ma thuật

Để trích dẫn docs :

Đối với người dùng Jupyter: Magics dành riêng và được cung cấp bởi kernel IPython. Liệu các phép thuật có sẵn trên kernel hay không là một quyết định được đưa ra bởi nhà phát triển kernel trên cơ sở mỗi kernel. Để hoạt động chính xác, Magics phải sử dụng một yếu tố cú pháp không hợp lệ trong ngôn ngữ cơ bản. Ví dụ, nhân IPython sử dụng phần tử cú pháp % cho các phép thuật vì % không phải là toán tử đơn nguyên hợp lệ trong Python. Trong khi, phần tử cú pháp có ý nghĩa trong các ngôn ngữ khác.

Điều này thường được sử dụng trong máy tính xách tay Jupyter và tương tự:

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]

Toán tử % trên mảng [trong hệ sinh thái NumPy/Pandas]

Toán tử % vẫn là toán tử modulo khi được áp dụng cho các mảng này, nhưng nó trả về một mảng chứa phần còn lại của mỗi phần tử trong mảng:

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

Tùy chỉnh toán tử % cho các lớp của riêng bạn

Tất nhiên, bạn có thể tùy chỉnh cách các lớp của riêng bạn hoạt động khi toán tử % được áp dụng cho chúng. Nói chung, bạn nên chỉ sử dụng nó để thực hiện các thao tác modulo! Nhưng đó là một hướng dẫn, không phải là một quy tắc cứng.

Chỉ cần cung cấp một ví dụ đơn giản cho thấy cách thức hoạt động của nó:

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]

Ví dụ này không thực sự hữu ích, nó chỉ in và sau đó ủy thác toán tử cho giá trị được lưu trữ, nhưng nó cho thấy __mod__ được gọi khi % được áp dụng cho một thể hiện:

>>> a = MyNumber[10]
>>> a % 2
__mod__ called on 'MyNumber[10]'
0

Lưu ý rằng nó cũng hoạt động cho %= mà không cần thực hiện rõ ràng __imod__:

>>> a = MyNumber[10]
>>> a %= 2
__mod__ called on 'MyNumber[10]'

>>> a
0

Tuy nhiên, bạn cũng có thể triển khai __imod__ một cách rõ ràng để ghi đè lên bài tập tăng thêm:

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]

Bây giờ %= được ghi đè rõ ràng để hoạt động tại chỗ:

>>> a = MyNumber[10]
>>> a %= 2
__imod__ called on 'MyNumber[10]'

>>> a
MyNumber[0]