| Server IP : 121.121.20.254 / Your IP : 216.73.216.202 Web Server : Microsoft-IIS/10.0 System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64 User : IUSR ( 0) PHP Version : 8.3.28 Disable Function : NONE MySQL : ON | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Python315/Lib/__pycache__/ |
Upload File : |
R
>lqj�/ c � � Q s ] QHGsGs , Q
Ns Q Q\Q5 s Q Q\2 s\O \2 Q
Q\2 s \ O \
2 Q Q\ 2 s Q Q\ 2 s \ O \
2 P! )z~Abstract Base Classes (ABCs) for numbers, according to PEP 3141.
TODO: Fill out more detailed documentation on the operators.)�ABCMeta�abstractmethod�Number�Complex�Real�Rational�Integralc �$ � \ sQ s]%sQsQsPsQsP! )r z�All numbers inherit from this class.
If you just want to check if an argument x is a number, without
caring what kind, use isinstance(x, Number).
� )�__name__�
__module__� __qualname__�__firstlineno__�__doc__� __slots__�__hash__�__static_attributes__r � � C:\Python315\\Lib\numbers.pyr r % s � ��
�I� �Hr )� metaclassc �P ` � \ sQ s]9s n QsQs\Q 2 sQ s\ \Q 2 2 s
\ \Q 2 2 s \Q 2 s \Q 2 s
\Q 2 s\Q 2 sQ
sQ s\Q 2 s\Q
2 s\Q 2 s\Q 2 s\Q 2 s\Q 2 s\Q 2 s\Q 2 s\Q 2 sQsU s P! )r aN Complex defines the operations that work on the builtin complex type.
In short, those are: a conversion to complex, .real, .imag, +, -,
*, /, **, abs(), .conjugate, ==, and !=.
If it is given heterogeneous arguments, and doesn't have special
knowledge about them, it should fall back to the builtin complex
type as described below.
c � � P! )z<Return a builtin complex instance. Called for complex(self).r ��selfs &r � __complex__�Complex.__complex__F s � r c � � U ] 6g ! )z)True if self != 0. Called for bool(self).r r s &r �__bool__�Complex.__bool__J s � ��q�y�r c � � [ g)zHRetrieve the real component of this number.
This should subclass Real.
��NotImplementedErrorr s &r �real� Complex.realN �
� � "�!r c � � [ g)zMRetrieve the imaginary component of this number.
This should subclass Real.
r r s &r �imag� Complex.imagW r# r c � � [ g)z self + otherr �r �others &&r �__add__�Complex.__add__` �
� � "�!r c � � [ g)z other + selfr r( s &&r �__radd__�Complex.__radd__e r, r c � � [ g)z-selfr r s &r �__neg__�Complex.__neg__j r, r c � � [ g)z+selfr r s &r �__pos__�Complex.__pos__o r, r c � � V' * ! )z self - otherr r( s &&r �__sub__�Complex.__sub__t s � ��f�}� r c � � U ' U* ! )z other - selfr r( s &&r �__rsub__�Complex.__rsub__x s � ��u�u�}� r c � � [ g)z self * otherr r( s &&r �__mul__�Complex.__mul__| r, r c � � [ g)z other * selfr r( s &&r �__rmul__�Complex.__rmul__� r, r c � � [ g)z5self / other: Should promote to float when necessary.r r( s &&r � __truediv__�Complex.__truediv__� r, r c � � [ g)z other / selfr r( s &&r � __rtruediv__�Complex.__rtruediv__� r, r c � � [ g)zDself ** exponent; should promote to float or complex when necessary.r )r �exponents &&r �__pow__�Complex.__pow__� r, r c � � [ g)z base ** selfr )r �bases &&r �__rpow__�Complex.__rpow__� r, r c � � [ g)z7Returns the Real distance from 0. Called for abs(self).r r s &r �__abs__�Complex.__abs__� r, r c � � [ g)z$(x+y*i).conjugate() returns (x-y*i).r r s &r � conjugate�Complex.conjugate� r, r c � � [ g)z
self == otherr r( s &&r �__eq__�Complex.__eq__� r, r r ) r
r r r
r r r r r �propertyr! r% r* r. r1 r4 r7 r: r= r@ rC rF rJ rN rQ rT rW r �__classdictcell__��
__classdict__s @r r r 9 sp �� � �� �I��K� �K�� ��"� � �"� ��"� � �"� �"� �"� �"� �"� �"� �"� �"� �"� � � �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"r c � ` � \ sQ s]�s n QsQs\Q 2 s\Q 2 s\Q 2 s \Q 2 s
\QQ k2 s Q s Q s
\Q 2 s\Q
2 s\Q 2 s\Q 2 s\Q
2 s\Q 2 sQ s\Q 2 s\Q 2 sQ sQsU sP! )r z�To Complex, Real adds the operations that work on real numbers.
In short, those are: a conversion to float, trunc(), divmod,
%, <, <=, >, and >=.
Real also provides defaults for the derived operations.
c � � [ g)zLAny Real can be converted to a native float object.
Called for float(self).r r s &r � __float__�Real.__float__� �
� �
"�!r c � � [ g)a trunc(self): Truncates self to an Integral.
Returns an Integral i such that:
* i > 0 iff self > 0;
* abs(i) <= abs(self);
* for any Integral j satisfying the first two conditions,
abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
i.e. "truncate towards 0".
r r s &r � __trunc__�Real.__trunc__� s
� � "�!r c � � [ g)z$Finds the greatest Integral <= self.r r s &r � __floor__�Real.__floor__� r, r c � � [ g)z!Finds the least Integral >= self.r r s &r �__ceil__�
Real.__ceil__� r, r c � � [ g)z�Rounds self to ndigits decimal places, defaulting to 0.
If ndigits is omitted or None, returns an Integral, otherwise
returns a Real. Rounds half toward even.
r )r �ndigitss &&r � __round__�Real.__round__� r# r c �$ � V* V* 1! )z�divmod(self, other): The pair (self // other, self % other).
Sometimes this can be computed faster than the pair of
operations.
r r( s &&r �
__divmod__�Real.__divmod__� s � � �
�t�|�,�,r c �$ � V* V* 1! )z�divmod(other, self): The pair (other // self, other % self).
Sometimes this can be computed faster than the pair of
operations.
r r( s &&r � __rdivmod__�Real.__rdivmod__� s � � �
�u�|�,�,r c � � [ g)z)self // other: The floor() of self/other.r r( s &&r � __floordiv__�Real.__floordiv__� r, r c � � [ g)z)other // self: The floor() of other/self.r r( s &&r �
__rfloordiv__�Real.__rfloordiv__� r, r c � � [ g)z self % otherr r( s &&r �__mod__� Real.__mod__� r, r c � � [ g)z other % selfr r( s &&r �__rmod__�
Real.__rmod__� r, r c � � [ g)zJself < other
< on Reals defines a total ordering, except perhaps for NaN.r r( s &&r �__lt__� Real.__lt__ ra r c � � [ g)z
self <= otherr r( s &&r �__le__� Real.__le__ r, r c �, � [ [ U 2 2 ! )z(complex(self) == complex(float(self), 0))�complex�floatr s &r r �Real.__complex__ s � ��u�T�{�#�#r c �
� U 3! )z&Real numbers are their real component.r r s &r r! � Real.real � � � �u� r c � � ] ! )z)Real numbers have no imaginary component.r r s &r r% � Real.imag � � � r c �
� U 3! )z Conjugate is a no-op for Reals.r r s &r rT �Real.conjugate s � ��u� r r �N)r
r r r
r r r r_ rc rf ri rm rp rs rv ry r| r r� r� r rY r! r% rT r rZ r[ s @r r r � s, �� � �� �I��"� �"� �
"� �
"� �"� �"� �"� �"� �"� �"�-�-� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"�
$� �� �� �� ��� r c �d ` � \ sQ sQs n QsQs\\Q 2 2 s\\Q 2 2 s Q s
Qs U s P! )r �$ z�To Real, Rational adds numerator and denominator properties.
The numerator and denominator values should be in lowest terms,
with a positive denominator.
c � � [ g)z3The numerator of a rational number in lowest terms.r r s &r � numerator�Rational.numerator- s
� � "�!r c � � [ g)z\The denominator of a rational number in lowest terms.
This denominator should be positive.
r r s &r � denominator�Rational.denominator3 r# r c �b � [ U O 2 [ U O 2 * ! )z�float(self) = self.numerator / self.denominator
It's important that this conversion use the integer's "true"
division rather than casting one side to float before dividing
so that ratios of huge integers convert without overflowing.
)�intr� r� r s &r r_ �Rational.__float__= s# � � �4�>�>�"�S��)9�)9�%:�:�:r r )
r
r r r
r r rY r r� r� r_ r rZ r[ s @r r r $ sQ �� � �� �I�
��"� � �"� ��"� � �"�;� ;r c �* ` � \ sQ sQs n QsQs\Q 2 sQ s\QQ k2 s \Q 2 s
\Q 2 s \Q 2 s \Q 2 s
\Q
2 s\Q 2 s\Q 2 s\Q
2 s\Q 2 s\Q 2 s\Q 2 sQ s\Q 2 s\Q 2 sQsU sP! )r �H z�Integral adds methods that work on integral numbers.
In short, these are conversion to int, pow with modulus, and the
bit-string operations.
c � � [ g)z int(self)r r s &r �__int__�Integral.__int__Q r, r c � � [ U 2 ! )z6Called whenever an index is needed, such as in slicing)r� r s &r � __index__�Integral.__index__V s � ��4�y�r c � � [ g)a self ** exponent % modulus, but maybe faster.
Accept the modulus argument if you want to support the
3-argument version of pow(). Raise a TypeError if exponent < 0
or any argument isn't Integral. Otherwise, just implement the
2-argument version described in Complex.
r )r rI �moduluss &&&r rJ �Integral.__pow__Z s
� � "�!r c � � [ g)z
self << otherr r( s &&r �
__lshift__�Integral.__lshift__e r, r c � � [ g)z
other << selfr r( s &&r � __rlshift__�Integral.__rlshift__j r, r c � � [ g)z
self >> otherr r( s &&r �
__rshift__�Integral.__rshift__o r, r c � � [ g)z
other >> selfr r( s &&r � __rrshift__�Integral.__rrshift__t r, r c � � [ g)z self & otherr r( s &&r �__and__�Integral.__and__y r, r c � � [ g)z other & selfr r( s &&r �__rand__�Integral.__rand__~ r, r c � � [ g)z self ^ otherr r( s &&r �__xor__�Integral.__xor__� r, r c � � [ g)z other ^ selfr r( s &&r �__rxor__�Integral.__rxor__� r, r c � � [ g)z self | otherr r( s &&r �__or__�Integral.__or__� r, r c � � [ g)z other | selfr r( s &&r �__ror__�Integral.__ror__� r, r c � � [ g)z~selfr r s &r �
__invert__�Integral.__invert__� r, r c �, � [ [ U 2 2 ! )z float(self) == float(int(self)))r� r� r s &r r_ �Integral.__float__� s � ��S��Y� � r c �
� U 3! )z"Integers are their own numerators.r r s &r r� �Integral.numerator� r� r c � � ]! )z!Integers have a denominator of 1.r r s &r r� �Integral.denominator� r� r r r� )r
r r r
r r r r� r� rJ r� r� r� r� r� r� r� r� r� r� r� r_ rY r� r� r rZ r[ s @r r r H sE �� � �� �I��"� �"�� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"� �"�
� �� �� �� �r )r r r r r )r �abcr r �__all__r r �registerr� r r� r r r� r r r �<module>r� s� ��@�: (�
?�� �w� �(n"�f� n"�` � � �� �s�7� s�j �
�
�e� �!;�t� !;�Ha�x� a�F � � �#� r