python～运算符_Python - 运算符

什么是运算符？

举个简单的例子:

4 + 5 = 9

例子中，4 和 5 被称为操作数，+ 称为运算符。

Python 语言支持以下类型的运算符:

1、算术运算符

以下假设变量a为10，变量b为21：

运算符

描述

实例

+

加 - 两个对象相加

a + b 输出结果 31

-

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -11

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 210

/

除 - x 除以 y

b / a 输出结果 2.1

%

取模 - 返回除法的余数

b % a 输出结果 1

**

幂 - 返回x的y次幂

a**b 为10的21次方

//

取整除 - 向下取接近商的整数

>>> 9//2 4 >>> -9//2 -5

以下实例演示了Python所有算术运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3

a = 21

b = 10

c = 0

c = a + b

print ("1 - c 的值为：", c)

c = a - b

print ("2 - c 的值为：", c)

c = a * b

print ("3 - c 的值为：", c)

c = a / b

print ("4 - c 的值为：", c)

c = a % b

print ("5 - c 的值为：", c)

# 修改变量 a 、b 、c

a = 2

b = 3

c = a**b

print ("6 - c 的值为：", c)

a = 10

b = 5

c = a//b

print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31

2 - c 的值为： 11

3 - c 的值为： 210

4 - c 的值为： 2.1

5 - c 的值为： 1

6 - c 的值为： 8

7 - c 的值为： 2

结果总是隐式转换为复杂类型

# 正负

>>> +x

521

>>> -x

-521

# 加法,可结合赋值运算+=

>>> x + 0

521

# 减法,可结合赋值运算-=

>>> x - 21

500

# 乘法,可结合赋值运算*=

>>> z * 100

521.0

# 除法,可结合赋值运算/=或//=

"""

兼容特性: from __future__ import division

"""

# Python2中对于包含小数使用真除法(保留小数部分,最终为小数)

>>> x / 100.

5.21

# Python3中对于包含小数使用真除法(保留小数部分,最终为小数)

>>> x / 100.

5.21

# Python2中对于全整数使用传统除法(保留整数部分,最终为整数)

>>> x / 100

5

# Python3中对于全整数使用真除法(保留小数部分,最终为小数)

>>> x / 100

5.21

# Python2中对于包含小数使用地板除(保留整数部分,最终为小数)

# Python3中对于包含小数使用地板除(保留整数部分,最终为小数)

>>> x // 100.

5.0

# Python2中对于全整数使用地板除(保留整数部分,最终为整数)

# Python3中对于全整数使用地板除(保留整数部分,最终为整数)

>>> x // 100

5

# 取模,可结合赋值运算%=

>>> x % 2

1

# 乘方,可结合赋值运算**=

>>> z * 10 ** 2

521.0

>>> 5 + 4 # 加法

9

>>> 4.3 - 2 # 减法

2.3

>>> 3 * 7 # 乘法

21

>>> 2 / 4 # 除法，得到一个浮点数

0.5

>>> 2 // 4 # 除法，得到一个整数

0

>>> 17 % 3 # 取余

2

>>> 2 ** 5 # 乘方

32

>>> 2 & (2 - 1)

0

>>> 8 & (8 - 1)

0

>>> 16 & (16 - 1)

0

2、比较运算符

以下假设变量a为10，变量b为20：

运算符

描述

实例

==

等于 - 比较对象是否相等

(a == b) 返回 False。

!=

不等于 - 比较两个对象是否不相等

(a != b) 返回 True。

>

大于 - 返回x是否大于y

(a > b) 返回 False。

<

小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。

(a < b) 返回 True。

>=

大于等于 - 返回x是否大于等于y。

(a >= b) 返回 False。

<=

小于等于 - 返回x是否小于等于y。

(a <= b) 返回 True。

以下实例演示了Python所有比较运算符的操作：

#!/usr/bin/python3

a = 21

b = 10

c = 0

if ( a == b ):

print ("1 - a 等于 b")

else:

print ("1 - a 不等于 b")

if ( a != b ):

print ("2 - a 不等于 b")

else:

print ("2 - a 等于 b")

if ( a < b ):

print ("3 - a 小于 b")

else:

print ("3 - a 大于等于 b")

if ( a > b ):

print ("4 - a 大于 b")

else:

print ("4 - a 小于等于 b")

# 修改变量 a 和 b 的值

a = 5;

b = 20;

if ( a <= b ):

print ("5 - a 小于等于 b")

else:

print ("5 - a 大于 b")

if ( b >= a ):

print ("6 - b 大于等于 a")

else:

print ("6 - b 小于 a")

以上实例输出结果：

1 - a 不等于 b

2 - a 不等于 b

3 - a 大于等于 b

4 - a 大于 b

5 - a 小于等于 b

6 - b 大于等于 a

# 值比较

# 小于

>>> y < x

True

# 小于等于

>>> x <= x

True

# 大于

>>> x > y

True

# 大于等于

>>> x >= y

True

# 等于

>>> x == x

True

# 不等于

# for Python2

>>> x != y

True

>>> x <> y

True

# for Python3

>>> x != y

True

# 地址比较

>>> id(x), id(521)

(140428868352096, 140428868352072)

>>> x is 521

False

3、赋值运算符

向内存申请一空闲内存单元存储数字然后将变量名指向此内存单元,至此可通过变量名操作此内存单元数据

以下假设变量a为10，变量b为20：

运算符

描述

实例

=

简单的赋值运算符

c = a + b 将 a + b 的运算结果赋值为 c

+=

加法赋值运算符

c += a 等效于 c = c + a

-=

减法赋值运算符

c -= a 等效于 c = c - a

*=

乘法赋值运算符

c *= a 等效于 c = c * a

/=

除法赋值运算符

c /= a 等效于 c = c / a

%=

取模赋值运算符

c %= a 等效于 c = c % a

**=

幂赋值运算符

c **= a 等效于 c = c ** a

//=

取整除赋值运算符

c //= a 等效于 c = c // a

:=

海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

在这个示例中，赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

以下实例演示了Python所有赋值运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3

a = 21

b = 10

c = 0

c = a + b

print ("1 - c 的值为：", c)

c += a

print ("2 - c 的值为：", c)

c *= a

print ("3 - c 的值为：", c)

c /= a

print ("4 - c 的值为：", c)

c = 2

c %= a

print ("5 - c 的值为：", c)

c **= a

print ("6 - c 的值为：", c)

c //= a

print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31

2 - c 的值为： 52

3 - c 的值为： 1092

4 - c 的值为： 52.0

5 - c 的值为： 2

6 - c 的值为： 2097152

7 - c 的值为： 99864

:point_right：混合操作符优先级问题可通过括号()提升优先级解决

:point_right：混合类型的转换以复杂度为基准,会自动转换至复杂度最高的类型

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

4、位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

运算符

描述

实例

&

按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

(a & b) 输出结果 12 ，二进制解释： 0000 1100

|

按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

(a | b) 输出结果 61 ，二进制解释： 0011 1101

^

按位异或运算符：当两对应的二进位相异时，结果为1

(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~

按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1

(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

<<

左移动运算符：运算数的各二进位全部左移若干位，由"<

a << 2 输出结果 240 ，二进制解释： 1111 0000

>>

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了Python所有位运算符的操作：

实例(Python 3.0+)

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

#!/usr/bin/python3

a = 60 # 60 = 0011 1100

b = 13 # 13 = 0000 1101

c = 0

c = a & b; # 12 = 0000 1100

print ("1 - c 的值为：", c)

c = a | b; # 61 = 0011 1101

print ("2 - c 的值为：", c)

c = a ^ b; # 49 = 0011 0001

print ("3 - c 的值为：", c)

c = ~a; # -61 = 1100 0011

print ("4 - c 的值为：", c)

c = a << 2; # 240 = 1111 0000

print ("5 - c 的值为：", c)

c = a >> 2; # 15 = 0000 1111

print ("6 - c 的值为：", c)

>>> bin(x)

'0b1000001001'

# 左移,可结合赋值运算<<=

"""

规则: 左

"""

>>> bin(x << 2)

'0b100000100100'

# 右移,可结合赋值运算>>=

>>> bin(x >> 2)

'0b10000010'

# 位与,可结合赋值运算&=

"""

规则: 都为1为1,否则为0

100000100100

000010000010

------------

000000000000

"""

>>> 0b100000100100 & 0b10000010

0

# 位或,可结合赋值运算|=

"""

规则: 存在1为1,否则为0

100000100100

000010000010

------------

100010100110

"""

>>> 0b100000100100 | 0b10000010

2214

# 异或,可结合赋值运算^=

"""

规则: 不同为1,相同为0

100000100100

000010000010

----------

100010100110

"""

>>> 0b100000100100 ^ 0b10000010

2214

# 取反,可结合赋值运算～=

"""

规则: 1变为0,0变为1

0000001000001001

----------------

1111110111110110 取反,此时最高位为1表示负数,负数的存储需要将其转换为补码

----------------

1000001000001001 反码,保持符号位不变,其它位置取反

----------------

1000001000001010 补码,在反码的基础上最低位+1

----------------

-522

"""

>>> ~0b1000001001

-522