mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
783 lines
34 KiB
ReStructuredText
783 lines
34 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_int:
|
||
|
||
int
|
||
===
|
||
|
||
Встроенный тип для целых чисел.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Описание
|
||
----------------
|
||
|
||
Знаковый 64-битный целочисленный тип. Это означает, что он может принимать значения от ``-2^63`` до ``2^63 - 1``, т.е. от ``-9223372036854775808`` до ``9223372036854775807``. При выходе за эти границы произойдет циклический возврат.
|
||
|
||
\ **int**-ы могут быть автоматически преобразованы в :ref:`float<class_float>`-ы при необходимости, например, при передаче их в качестве аргументов в функциях. :ref:`float<class_float>` будет максимально близок к исходному целому числу.
|
||
|
||
Аналогично, :ref:`float<class_float>`-ы можно автоматически преобразовать в **int**-ы. Это усечет :ref:`float<class_float>`, отбросив все после плавающей точки.
|
||
|
||
\ **Примечание:** В булевом контексте **int** будет оцениваться как ``false``, если он равен ``0``, и как ``true`` в противном случае.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var x: int = 1 # х равен 1
|
||
x = 4.2 # x равен 4, потому что 4.2 усекается
|
||
var max_int = 9223372036854775807 # Наибольшее значение, которое может хранить int
|
||
max_int += 1 # max_int равен -9223372036854775808, потому что он обернулся вокруг
|
||
|
||
.. code-tab:: csharp
|
||
|
||
int x = 1; // x равен 1
|
||
x = (int)4.2; // x равен 4, потому что 4.2 усекается
|
||
// Ниже мы используем long, поскольку int в GDScript является 64-битным, а int в C# — 32-битным.
|
||
long maxLong = 9223372036854775807; // Наибольшее значение, которое может храниться в long
|
||
maxLong++; // maxLong равен now -9223372036854775808, потому что он обернулся.
|
||
|
||
// Альтернативой может служить 32-битный тип int в C#, имеющий меньшее максимальное значение.
|
||
int maxInt = 2147483647; // Наибольшее значение, которое может хранить int
|
||
maxInt++; // maxInt теперь равен -2147483648, потому что он был перенесен
|
||
|
||
|
||
|
||
Вы можете использовать литерал ``0b`` для двоичного представления, литерал ``0x`` для шестнадцатеричного представления и символ ``_`` для разделения длинных чисел и улучшения читаемости.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var x = 0b1001 # x равен 9
|
||
var y = 0xF5 # y равен 245
|
||
var z = 10_000_000 # z равен 10000000
|
||
|
||
.. code-tab:: csharp
|
||
|
||
int x = 0b1001; // x равен 9
|
||
int y = 0xF5; // y равен 245
|
||
int z = 10_000_000; // z равен 10000000
|
||
|
||
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструкторы
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ ) |
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`String<class_String>`\ ) |
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`bool<class_bool>`\ ) |
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`float<class_float>`\ ) |
|
||
+-----------------------+---------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Операторы
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_int_operator_neq_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_int_operator_neq_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator %<class_int_operator_mod_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator &<class_int_operator_bwand_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Color<class_Color>` | :ref:`operator *<class_int_operator_mul_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator *<class_int_operator_mul_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_int_operator_mul_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector2i<class_Vector2i>` | :ref:`operator *<class_int_operator_mul_Vector2i>`\ (\ right\: :ref:`Vector2i<class_Vector2i>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_int_operator_mul_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector3i<class_Vector3i>` | :ref:`operator *<class_int_operator_mul_Vector3i>`\ (\ right\: :ref:`Vector3i<class_Vector3i>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_int_operator_mul_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4i<class_Vector4i>` | :ref:`operator *<class_int_operator_mul_Vector4i>`\ (\ right\: :ref:`Vector4i<class_Vector4i>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator *<class_int_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator *<class_int_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator **<class_int_operator_pow_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator **<class_int_operator_pow_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator +<class_int_operator_sum_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator +<class_int_operator_sum_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator -<class_int_operator_dif_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator -<class_int_operator_dif_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator /<class_int_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator /<class_int_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<<class_int_operator_lt_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<<class_int_operator_lt_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator \<\<<class_int_operator_bwsl_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_int_operator_lte_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_int_operator_lte_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_int_operator_eq_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_int_operator_eq_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ><class_int_operator_gt_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ><class_int_operator_gt_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator >=<class_int_operator_gte_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator >=<class_int_operator_gte_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator >><class_int_operator_bwsr_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator ^<class_int_operator_bwxor_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator unary+<class_int_operator_unplus>`\ (\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator unary-<class_int_operator_unminus>`\ (\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator |<class_int_operator_bwor_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`operator ~<class_int_operator_bwnot>`\ (\ ) |
|
||
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания конструктора
|
||
------------------------------------------
|
||
|
||
.. _class_int_constructor_int:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`int<class_int>` **int**\ (\ ) :ref:`🔗<class_int_constructor_int>`
|
||
|
||
Создает **int**, установленный на ``0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`int<class_int>` **int**\ (\ from\: :ref:`int<class_int>`\ )
|
||
|
||
Создает **int** как копию заданного **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`int<class_int>` **int**\ (\ from\: :ref:`String<class_String>`\ )
|
||
|
||
Создает новый **int** из :ref:`String<class_String>` по тем же правилам, что и :ref:`String.to_int()<class_String_method_to_int>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`int<class_int>` **int**\ (\ from\: :ref:`bool<class_bool>`\ )
|
||
|
||
Создает новый **int** из :ref:`bool<class_bool>`. ``true`` преобразуется в ``1``, а ``false`` преобразуется в ``0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`int<class_int>` **int**\ (\ from\: :ref:`float<class_float>`\ )
|
||
|
||
Конструирует новый **int** из :ref:`float<class_float>`. Это обрежет :ref:`float<class_float>`, отбросив все, что находится после плавающей точки.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания оператора
|
||
------------------------------------
|
||
|
||
.. _class_int_operator_neq_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_neq_float>`
|
||
|
||
Возвращает ``true``, если **int** не эквивалентно :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_neq_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_neq_int>`
|
||
|
||
Возвращает ``true``, если **int**-ы не равны.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mod_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator %**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_mod_int>`
|
||
|
||
Возвращает остаток после деления двух **int**. Использует усеченное деление, которое возвращает отрицательное число, если делимое отрицательно. Если это нежелательно, рассмотрите возможность использования :ref:`@GlobalScope.posmod()<class_@GlobalScope_method_posmod>`.
|
||
|
||
::
|
||
|
||
print(6 % 2) # Prints 0
|
||
print(11 % 4) # Prints 3
|
||
print(-5 % 3) # Prints -2
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwand_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator &**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwand_int>`
|
||
|
||
Выполняет побитовую операцию ``AND``.
|
||
|
||
::
|
||
|
||
print(0b1100 & 0b1010) # Печатает 8 (двоичное 1000)
|
||
|
||
Это полезно для извлечения двоичных флагов из переменной.
|
||
|
||
::
|
||
|
||
var flags = 0b101
|
||
# Проверьте, включен ли первый или второй бит.
|
||
if flags & 0b011:
|
||
do_stuff() # Эта линия будет работать.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Color:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Color<class_Color>` **operator ***\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_int_operator_mul_Color>`
|
||
|
||
Умножает каждый компонент :ref:`Color<class_Color>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_int_operator_mul_Quaternion>`
|
||
|
||
Умножает каждый компонент :ref:`Quaternion<class_Quaternion>` на **int**. Эта операция сама по себе не имеет смысла, но ее можно использовать как часть большего выражения.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector2:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_int_operator_mul_Vector2>`
|
||
|
||
Умножает каждый компонент :ref:`Vector2<class_Vector2>` на **int**.
|
||
|
||
::
|
||
|
||
print(2 * Vector2(1, 4)) # Выводит (2, 8)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector2i:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector2i<class_Vector2i>` **operator ***\ (\ right\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_int_operator_mul_Vector2i>`
|
||
|
||
Умножает каждый компонент :ref:`Vector2i<class_Vector2i>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector3:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_int_operator_mul_Vector3>`
|
||
|
||
Умножает каждый компонент :ref:`Vector3<class_Vector3>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector3i:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector3i<class_Vector3i>` **operator ***\ (\ right\: :ref:`Vector3i<class_Vector3i>`\ ) :ref:`🔗<class_int_operator_mul_Vector3i>`
|
||
|
||
Умножает каждый компонент :ref:`Vector3i<class_Vector3i>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_int_operator_mul_Vector4>`
|
||
|
||
Умножает каждый компонент :ref:`Vector4<class_Vector4>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_Vector4i:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4i<class_Vector4i>` **operator ***\ (\ right\: :ref:`Vector4i<class_Vector4i>`\ ) :ref:`🔗<class_int_operator_mul_Vector4i>`
|
||
|
||
Умножает каждый компонент :ref:`Vector4i<class_Vector4i>` на **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_mul_float>`
|
||
|
||
Умножает :ref:`float<class_float>` на **int**. Результат — :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_mul_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_mul_int>`
|
||
|
||
Умножает два **int**-а.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_pow_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator ****\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_pow_float>`
|
||
|
||
Возводит **int** в степень :ref:`float<class_float>`. Результат — :ref:`float<class_float>`.
|
||
|
||
::
|
||
|
||
print(2 ** 0.5) # Выводит 1.4142135623731
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_pow_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator ****\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_pow_int>`
|
||
|
||
Возводит левое **int** в степень правого **int**.
|
||
|
||
::
|
||
|
||
print(3 ** 4) # Выводит 81
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_sum_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator +**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_sum_float>`
|
||
|
||
Складывает **int** и :ref:`float<class_float>`. Результат — :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_sum_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator +**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_sum_int>`
|
||
|
||
Складывает два **int**-а.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_dif_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator -**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_dif_float>`
|
||
|
||
Вычитает :ref:`float<class_float>` из **int**. Результат — :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_dif_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator -**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_dif_int>`
|
||
|
||
Вычитает два **int**-а.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_div_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_div_float>`
|
||
|
||
Делит **int** на :ref:`float<class_float>`. Результат — :ref:`float<class_float>`.
|
||
|
||
::
|
||
|
||
print(10 / 3.0) # Выводит 3.33333333333333
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_div_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_div_int>`
|
||
|
||
Делит два **int**-а. Результат — **int**. Это обрежет :ref:`float<class_float>`, отбросив все после плавающей точки.
|
||
|
||
::
|
||
|
||
print(6 / 2) # Prints 3
|
||
print(5 / 3) # Prints 1
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_lt_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_lt_float>`
|
||
|
||
Возвращает ``true``, если **int** меньше, чем :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_lt_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_lt_int>`
|
||
|
||
Возвращает ``true``, если левое **int** меньше правого **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwsl_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator <<**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwsl_int>`
|
||
|
||
Выполняет операцию побитового сдвига влево. По сути то же самое, что и умножение на степень 2.
|
||
|
||
::
|
||
|
||
print(0b1010 << 1) # Печатает 20 (двоичное 10100)
|
||
print(0b1010 << 3) # Печатает 80 (двоичное 1010000)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_lte_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_lte_float>`
|
||
|
||
Возвращает ``true``, если **int** меньше или равно :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_lte_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_lte_int>`
|
||
|
||
Возвращает ``true``, если левое **int** меньше или равно правому **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_eq_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_eq_float>`
|
||
|
||
Возвращает ``true``, если **int** равно :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_eq_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_eq_int>`
|
||
|
||
Возвращает ``true``, если два **int**-а равны.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_gt_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_gt_float>`
|
||
|
||
Возвращает ``true``, если **int** больше, чем :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_gt_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_gt_int>`
|
||
|
||
Возвращает ``true``, если левое **int** больше правого **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_gte_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_gte_float>`
|
||
|
||
Возвращает ``true``, если **int** больше или равно :ref:`float<class_float>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_gte_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_gte_int>`
|
||
|
||
Возвращает ``true``, если левое **int** больше или равно правому **int**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwsr_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator >>**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwsr_int>`
|
||
|
||
Выполняет операцию побитового сдвига вправо. По сути то же самое, что деление на степень числа 2.
|
||
|
||
::
|
||
|
||
print(0b1010 >> 1) # Печатает 5 (двоичное 101)
|
||
print(0b1010 >> 2) # Печатает 2 (двоичное 10)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwxor_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator ^**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwxor_int>`
|
||
|
||
Выполняет побитовую операцию ``XOR``.
|
||
|
||
::
|
||
|
||
print(0b1100 ^ 0b1010) # Печатает 6 (двоичное 110)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_unplus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator unary+**\ (\ ) :ref:`🔗<class_int_operator_unplus>`
|
||
|
||
Возвращает то же значение, как если бы ``+`` не было. Унарный ``+`` ничего не делает, но иногда он может сделать ваш код более читаемым.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_unminus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator unary-**\ (\ ) :ref:`🔗<class_int_operator_unminus>`
|
||
|
||
Возвращает отрицательное значение **int**. Если положительное, делает число отрицательным. Если отрицательное, делает число положительным. Если ноль, ничего не делает.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwor_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator |**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwor_int>`
|
||
|
||
Выполняет побитовую операцию ``OR`` .
|
||
|
||
::
|
||
|
||
print(0b1100 | 0b1010) # Печатает 14 (двоичное 1110)
|
||
|
||
Это полезно для хранения двоичных флагов в переменной.
|
||
|
||
::
|
||
|
||
var flags = 0
|
||
flags |= 0b101 # Включите первый и третий биты.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_int_operator_bwnot:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`int<class_int>` **operator ~**\ (\ ) :ref:`🔗<class_int_operator_bwnot>`
|
||
|
||
Выполняет побитовую операцию ``NOT`` над **int**. Благодаря `2's complement <https://en.wikipedia.org/wiki/Two%27s_complement>`__ она фактически равна ``-(int + 1)``.
|
||
|
||
::
|
||
|
||
print(~4) # Prints -5
|
||
print(~(-7)) # Prints 6
|
||
|
||
.. |virtual| replace:: :abbr:`virtual (Этот метод обычно должен быть переопределен пользователем, чтобы иметь какой-либо эффект.)`
|
||
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
||
.. |const| replace:: :abbr:`const (Этот метод не имеет побочных эффектов. Он не изменяет ни одну из переменных-членов экземпляра.)`
|
||
.. |vararg| replace:: :abbr:`vararg (Этот метод принимает любое количество аргументов после описанных здесь.)`
|
||
.. |constructor| replace:: :abbr:`constructor (Этот метод используется для создания типа.)`
|
||
.. |static| replace:: :abbr:`static (Этот метод не нуждается в вызове экземпляра, поэтому его можно вызвать напрямую, используя имя класса.)`
|
||
.. |operator| replace:: :abbr:`operator (Этот метод описывает допустимый оператор для использования с этим типом в качестве левого операнда.)`
|
||
.. |bitfield| replace:: :abbr:`BitField (Это значение является целым числом, составленным как битовая маска следующих флагов.)`
|
||
.. |void| replace:: :abbr:`void (Нет возвращаемого значения.)`
|