Python——int

最新推荐文章于 2024-04-30 19:24:04 发布

星燎

最新推荐文章于 2024-04-30 19:24:04 发布

阅读量1.3k

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/weixin_44284498/article/details/125645921

版权

Python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1 介绍

在Python中有多种内置的数据类型，如int、float、str、dict、list等。
在本文中，会介绍int数据类型中一些内置的方法。

int类型的部分内置方法如下：

class int:
    @overload
    def __new__(cls: type[Self], __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> Self: ...
    @overload
    def __new__(cls: type[Self], __x: str | bytes | bytearray, base: SupportsIndex) -> Self: ...
    def bit_length(self) -> int: ...
    def __add__(self, __x: int) -> int: ...
    def __sub__(self, __x: int) -> int: ...
    def __mul__(self, __x: int) -> int: ...
   
	...

上述定义可以看出，int类型实际上是一个Python类,其里面提供了许多内置方法，在本文中不会介绍全部的方法，只会介绍大部分可能会用到的方法。
为了方便表达，在后续的篇幅中，会使用num来代表当前的数值，而value代表的是每个方法中需要传入的参数。

2 str 转 int

在Python中，可以将str类型的整数转换为int类型，转换示例如下：

num="17"
print(num)
print(type(num))
num=int(num)
print(num)
print(type(num))

# 运行结果:
17
<class 'str'>
17
<class 'int'>

上面的示例中int(num)会将str类型的十进制整数转换成int类型，那么能不能将str类型的其他进制数转换成int类型呢？

答案是可以的，示例如下：

hexNum="1a"
print(hexNum)
# 将hexNum以16进制的形式转换成int类型
num=int(hexNum,16)
print(num)
print(type(num))
# 将hexNum以32进制的形式转换成int类型
num=int(hexNum,32)
print(num)
print(type(num))

# 运行结果：
1a
26
<class 'int'>
42
<class 'int'>

上面的示例中int(hexNum,16)就是将str类型的字符串以16进制数的形式转换成int类型的整数。

# int.__new__的定义
	@overload
    def __new__(cls: type[Self], __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> Self: ...
    @overload
    def __new__(cls: type[Self], __x: str | bytes | bytearray, base: SupportsIndex) -> Self: ...

从上面的定义中可以得知，执行int("12")时，会调用第一个__new__方法，而当执行int("1a",16)时则会执行第二个__new__方法。

因此对于int()，可以接收0 - 2个参数。

参数个数	说明
0个	无，数值默认为0
1个	将参数1的值以十进制的方式转成int类型【eg：int(“11”)】
2个	将参数1的值以参数2代表的进制类型转成int类型【eg：int(“1a”,16)】。参数2的取值范围：[2 , 36]，即代表只支持二进制到36进制的转换

3 算术运算

对于int类型，它提供了多种算术运算，不同的方法会对num和value进行对应的操作。

算术运算对应的方法如下：

方法名	对应运算	示例	说明
`__add__`	加法	`num.__add__(value)`	返回（num + value）的和
`__radd__`	加法	`num.__radd__(value)`	返回（value + num）的和
`__sub__`	减法	`num.__sub__(value)`	返回（num - value）的差
`__rsub__`	减法	`num.__rsub__(value)`	返回（value - num）的差
`__mul__`	乘法	`num.__mul__(value)`	返回（num * value）的积
`__rmul__`	乘法	`num.__rmul__(value)`	返回（value * num）的积
`__floordiv__`	整除	`num.__floordiv__(value)`	返回（num // value）的商[整数]
`__rfloordiv__`	整除	`num.__rfloordiv__(value)`	返回（value // num）的商[整数]
`__truediv__`	除法	`num.__truediv__(value)`	返回（num / value）的商[浮点数]
`__rtruediv__`	除法	`num.__rtruediv__(value)`	返回（value / num）的商[浮点数]
`__mod__`	取余	`num.__mod__(value)`	返回（num % value）的余数
`__rmod__`	取余	`num.__rmod__(value)`	返回（value % num）的余数
`__divmod__`	求商取余	`num.__divmod__(value)`	返回（num ➗ value）对应的商[整数]和余数
`__rdivmod__`	求商取余	`num.__rdivmod__(value)`	返回（value ➗ num）的商[整数]和余数

*注：调用上述方法后，不会改变 num 自身的数值。

4 比较运算

int类型除了提供算术运算之外还提供了比较运算。

比较运算对应的方法如下：

方法名	对应运算	示例	说明
`__eq__`	等于	`num.__eq__(value)`	返回（num == value）的值 [真\|假]
`__ne__`	不等于	`num.__ne__(value)`	返回（num != value）的值 [真\|假]
`__lt__`	小于	`num.__lt__(value)`	返回（num < value）的值 [真\|假]
`__le__`	小于等于	`num.__le__(value)`	返回（num <= value）的值 [真\|假]
`__gt__`	大于	`num.__gt__(value)`	返回（num > value）的值 [真\|假]
`__ge__`	大于等于	`num.__ge__(value)`	返回（num >= value）的值 [真\|假]

5 按位运算

int类型中有根据num的二进制进行的位运算。

需要注意的是位运算时数值应为补码的形式进行。

对于正数而言，其补码与原码一样；而对于负数而言，其补码是对原码进行符号位不变，数值位按位取反,末位再加1的操作。

5.1 `and`

# 定义
def __and__(self, __n: int) -> int: ...

# 调用格式：
num.__and__(value)

在int类型中，__and__方法的返回值是对num与value进行按位与（&）操作后所产生的结果。

按位与：在操作过程中，只有num与value这两者的二进制中相对应的位都是1时结果才为1，否则为0。

示例如下：

num=-12
print(num.__and__(10))
print(num.__and__(8))
print(num.__and__(4))
print(num.__and__(-1))
# 运行结果：
0
0
4
-12

# 运算过程：
# 十进制			符号位   对应二进制   	按位与操作后结果	结果对应的十进制
# -12				1       0100
# 10				0		1010		0   0000	->  	0
# 8					0		1000		0	0000	->		0
# 4					0		0100		0   0100	->		4
# -1				1		1111		1	0100	->		-12

5.2 `or`

# 定义
def __or__(self, __n: int) -> int: ...

# 调用格式：
num.__or__(value)

在int类型中，返回按位或（|）操作结果所对应的方法为__or__，其调用的形式与__and__一样。

按位或：在操作过程中，当num与value这两者的二进制中相对应的位都是0时结果才为0，否则为1。

示例如下：

num= -12
print(num.__or__(10))
print(num.__or__(8))
print(num.__or__(4))
print(num.__or__(-1))
# 运行结果：
-2
-4
-12
-1

# 运算过程：
# 十进制			符号位   对应二进制   	按位或操作后结果	结果对应的十进制
# -12				1       0100
# 10				0		1010		1   1110		->  -2
# 8					0		1000		1	1100		->	-4
# 4					0		0100		1   0100		->	-12
# -1				1		1111		1	1111		->	-1

5.3 `xor`

# 定义
def __xor__(self, __n: int) -> int: ...

# 调用格式：
num.__xor__(value)

在int类型中，__xor__便是求num与value进行按位异或（^）后的结果。其调用方式与__and__、__or__一样。

按位异或：在操作过程中，只有num与value这两者的二进制中相对应的位的值不同时结果才为1，否则为0。

示例如下：

num= -12
print(num.__xor__(10))
print(num.__xor__(8))
print(num.__xor__(4))
print(num.__xor__(-1))
# 运行结果：
-2
-4
-16
11

# 运算过程：
# 十进制			符号位   对应二进制   	按位异或操作后结果	结果对应的十进制
# -12				1       0100
# 10				0		1010		1   1110		->  -2
# 8					0		1000		1	1100		->	-4
# 4					0		0100		1   0000		->	-16
# -1				1		1111		0	1011		->	11

5.4 `lshift`

# 定义
def __lshift__(self, __n: int) -> int: ...

# 调用格式：
num.__lshift__(value)

__lshift__方法返回的是num经过左移（算术左移）后的数值。此时 value 为左移的位数。

算术左移：将二进制数各位依次左移指定位数，尾部补0，最高的符号位保持不变。

示例如下：

num=-12
print(num.__lshift__(1))
print(num.__lshift__(2))

# 运行结果：
-24
-48

# 运算过程：
# 十进制			符号位		二进制			执行左移操作			结果对应的十进制
# -12				1		1111 0100		1	1110 1000		-24
# -12				1		1111 0100		1	1101 0000		-48

5.5 `rshift`

# 定义
def __rshift__(self, __n: int) -> int: ...

# 调用格式：
num.__rshift__(value)

__rshift__方法返回的是 num 经过右移（算术右移）后的数值。此时 value 为右移的位数。

算术右移：将二进制数各位依次右移指定位数，然后在左侧用原符号位补齐。

示例如下：

num=-12
print(num.__rshift__(1))
print(num.__rshift__(2))

# 运行结果：
-6
-3

# 运算过程：
# 十进制			符号位		二进制			执行右移操作			结果对应的十进制
# -12				1		1111 0100		1	1111 1010		-6
# -12				1		1111 0100		1	1111 1101		-3

5.6 `rand`

__rand__方法实现的跟__and__一样，都是对当前数与传入的数进行 按位与 的操作。不同的地方在于__and__执行的是num&value；而__rand__执行的是value&num。

示例如下：

num=-12
print(num.__rand__(10))
print(num.__rand__(8))
print(num.__rand__(4))
print(num.__rand__(-1))

# 运行结果：
0
0
4
-12

5.7 `ror`

__ror__方法实现的跟__or__一样，都是对当前数与传入的数进行 按位或 的操作。不同的地方在于__or__执行的是num|value；而__ror__执行的是value|num。

示例如下：

num= -12
print(num.__ror__(10))
print(num.__ror__(8))
print(num.__ror__(4))
print(num.__ror__(-1))

# 运行结果：
-2
-4
-12
-1

5.8 `rxor`

__rxor__方法实现的跟__xor__一样，都是对 num 与 value 进行 按位异或 的操作。不同的地方在于__xor__执行的是num^value；而__rxor__执行的是value^num。

示例如下：

num= -12
print(num.__rxor__(10))
print(num.__rxor__(8))
print(num.__rxor__(4))
print(num.__rxor__(-1))
# 运行结果：
-2
-4
-16
11

5.9 `rlshift`

# 定义
def __rlshift__(self, __n: int) -> int: ...

# 调用格式：
num.__rlshift__(value)

__rlshift__方法返回的是 value 经过左移（算术左移）后的数值。此时 num 为左移的位数。

示例如下：

num=3
print(num.__rlshift__(1))
print(num.__rlshift__(2))

# 运行结果：
8
16

# 运算过程：
# 十进制			符号位		二进制			执行左移操作			结果对应的十进制
# 1					0		0001			0	0000 1000			8
# 2					0		0010			0	0001 0000			16

5.10 `rrshift`

# 定义
def __rrshift__(self, __n: int) -> int: ...

# 调用格式：
num.__rrshift__(value)

__rrshift__方法返回的是 value 经过右移（算术右移）后的数值。此时 num 为右移的位数。

示例如下：

num=3
print(num.__rrshift__(16))
print(num.__rrshift__(9))

# 运行结果：
2
1

# 运算过程：
# 十进制			符号位		二进制			执行右移操作			结果对应的十进制
# 16				0		0001 0000		0	0000 0010			2
# 9					0		0000 1001		0	0000 0001			1

6 其它运算

6.1 `float`

# 定义
def __float__(self) -> float: ...

# 调用格式：
num.__float__()

在Python中，把int类型转为float类型常见的方法就是：float(num)。

在int类型中，也有将自身转为float类型的方法：__float__

示例如下：

num=12
print(num)
print(type(num))
print(num.__float__())
print(type(num.__float__()))

# 运行结果：
# 12
# <class 'int'>
# 12.0
# <class 'float'>

6.2 `abs`

# 定义
def __abs__(self) -> int: ...

# 调用格式：
num.__abs__()

在Python中，求整数的绝对值常见的方法就是：abs(num)。

在int类型中，有求自身绝对值的方法：__abs__

示例如下：

num=-12
print(num)
print(num.__abs__())

# 运行结果：
-12
12

6.3 `to_bytes`

# 定义
def to_bytes(self, length: SupportsIndex, byteorder: Literal["little", "big"], *, signed: bool = ...) -> bytes: ...

# 调用格式：
num.to_bytes(value1,value2[,signed=True])

to_bytes是int类型的一个方法，它能够将 num 从int类型的整数转成bytes类型的字节。其中 value1 代表的是需要将 num 转成长度为 value1 的字节；而 value2 代表字节存储的方式是以大端格式还是小端格式，因而 value2 的取值只有两种："little"或者"big"。

*注：当num为负数时，需要增加传入的参数：signed=True，否则出错。

示例如下：

num=17
print(num.to_bytes(5,"big"))
print(type(num.to_bytes(5,"big")))
num=-17
print(num.to_bytes(3,"big",signed=True))
print(type(num.to_bytes(3,"big",signed=True)))

# 运行效果：
# b'\x00\x00\x00\x00\x11'
# <class 'bytes'>
# b'\xff\xff\xef'
# <class 'bytes'>

6.4 `from_bytes`

# 定义
@classmethod
def from_bytes(cls: type[Self],bytes: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer,byteorder: Literal["little", "big"],*,signed: bool = ...,) -> Self: ...

# 调用格式：
int.from_bytes(value1,value2[,signed=True])

有int类型转bytes类型的to_bytes方法，同样的，也有将bytes类型转int类型的。

from_bytes就是将bytes类型转成int类型的方法。对于该方法，value1 为bytes类型的整数，value2 代表 value1 存储的方式是以大端格式还是小端格式，因而取值只有两种："little"或者"big"。

*注：当 value1 为负数时，需要增加传入的参数：signed=True，否则解析出错。

示例如下：

num=b'\xff\xff\xff\xff\xef'
print(int.from_bytes(num,"big"))
print(int.from_bytes(num,"big",signed=True))

# 运行结果：
# 1099511627759
# -17

7 结语

以上就是本人对于python内置数据类型中的int类型内部一些方法的理解。如有错误的地方，欢迎指正～

星燎

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Python——int

Python——int
复制链接

扫一扫

专栏目录

Python——int

1 介绍

2 str 转 int

3 算术运算

4 比较运算

5 按位运算

5.1 __and__

5.2 __or__

5.3 __xor__

5.4 __lshift__

5.5 __rshift__

5.6 __rand__

5.7 __ror__

5.8 __rxor__

5.9 __rlshift__

5.10 __rrshift__

6 其它运算

6.1 __float__

6.2 __abs__

6.3 to_bytes

6.4 from_bytes

7 结语

“相关推荐”对你有帮助么？

5.1 `and`

5.2 `or`

5.3 `xor`

5.4 `lshift`

5.5 `rshift`

5.6 `rand`

5.7 `ror`

5.8 `rxor`

5.9 `rlshift`

5.10 `rrshift`

6.1 `float`

6.2 `abs`

6.3 `to_bytes`

6.4 `from_bytes`