Python 运算符解析 | Python 编程语言

算数运算符

算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python 支持所有基本算术运算符。

接下来将对表 1 中各个算术运算符的用法逐一讲解。

+ 加法运算符

加法运算符很简单，和数学中的规则一样，请看下面的代码：

m = 10
n = 97
sum1 = m + n

x = 7.2
y = 15.3
sum2 = x + y

# sum1=107, sum2=22.50
print("sum1=%d, sum2=%.2f" % (sum1, sum2) )

拼接字符串

当 + 用于数字时表示加法，但是当 + 用于字符串时，它还有拼接字符串（将两个字符串连接为一个）的作用，请看代码：

name = "C语言中文网"
url = "http://c.biancheng.net/"
age = 8
info = name + "的网址是" + url + "，它已经" + str(age) + "岁了。"
# C语言中文网的网址是http://c.biancheng.net/，它已经8岁了。
print(info)

- 减法运算符

减法运算也和数学中的规则相同，请看代码：

n = 45
m = -n

x = -83.5
y = -x
# -45 , 83.5
print(m, ",", y)

求负数

- 除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数），请看下面的代码：

n = 45
n_neg = -n

f = -83.5
f_neg = -f
# -45 , 83.5
print(n_neg, ",", f_neg)

注意，单独使用 + 是无效的，不会改变数字的值，例如：

n = 45
m = +n

x = -83.5
y = +x

# 45 , -83.5
print(m, ",", y)

＊乘法运算符

乘法运算也和数学中的规则相同，请看代码：

n = 4 * 25
f = 34.5 * 2
# 100 , 69.0
print(n, ",", f)

重复字符串

* 除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来，请看代码：

# Hello hello hello hello 
str1 = "hello "print(str1 * 4)

/ 和 // 除法运算符

Python 支持 / 和 // 两个除法运算符，但它们之间是有区别的：

• / 表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
• // 表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。

请看下面的例子：

print("23/5 =", 23/5) # 4.6  
print("23//5 =", 23//5) # 4
print("23.0//5 =", 23.0//5) # 4.0  

从运行结果可以发现：

• / 的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
• 当有小数参与运算时，// 结果才是小数，否则就是整数。

需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致 ZeroDivisionError 错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。

Python 2. X 中的除法

Python 2. X 只提供了一种除法运算，就是 /，它的行为和大部分编程语言中 / 的行为是一样的：

• 当 / 两边都是整数时，结果始终是整数；如果不能除尽，就直接舍弃小数部分。
• 当 / 两边有一个是小数时，结果始终是小数；如果恰好除尽，小数部分就是 0。

请看下面的代码：

print 18/6 # 3
print 47/7 # 6
print 18.0/6 # 3.0
print 47.0/7 # 6.71428571429  
print 29.5/4.2 # 7.02380952381

你可以将 Python 2. X 中的 / 看作 Python 3. X 中 / 和 // 的结合体，因为 Python 2. X 中 / 的行为有点奇怪，所以 Python 3. X 增加了 // 运算符，用以规范除法运算的行为。

% 求余运算符

Python % 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。

注意，求余运算的本质是除法运算，所以第二个数字也不能是 0，否则会导致 ZeroDivisionError 错误。

Python % 使用示例：

print("-----整数求余-----")
print(15%6) # 3
print(-15%6) # 3
print(15%-6) # -3
print(-15%-6) # -3
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2) # 1.0999999999999996  
print("-7.7%2.2 =", -7.7%2.2) #1.1000000000000005  
print("7.7%-2.2 =", 7.7%-2.2)#-1.1000000000000005  
print("-7.7%-2.2 =", -7.7%-2.2)#-1.0999999999999996  
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)#5.5  
print("23%6.5 =", 23%6.5)#3.5  
print("23.5%-6 =", 23.5%-6)#-0.5  
print("-23%6.5 =", -23%6.5)#3.0  
print("-23%-6.5 =", -23%-6.5)#-3.5

从运行结果可以发现两点：

• 只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
• % 两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。

** 次方（乘方）运算符

Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算。Python ** 运算符示例：

print('----次方运算----')
print('3**4 =', 3**4)#81 
print('2**5 =', 2**5)#32
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))#3.0
print('32**(1/5) =', 32**(1/5))#2.0

三目运算符

Python 是一种极简主义的编程语言，它没有引入 ? : 这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。使用 if else 实现三目运算符（条件运算符）的格式如下：

exp1 if contion else exp2

Condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。

三目运算符的嵌套

Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：

a if a>b else c if c>d else d
# 等效
a if a>b else ( c if c>d else d )

赋值运算符

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。

Python 中最基本的赋值运算符是等号=；结合其它运算符，=还能扩展出更强大的赋值运算符。

基本赋值运算符

= 是 Python 中最常见、最基本的赋值运算符，用来将一个表达式的值赋给另一个变量，请看下面的例子：

#将字面量（直接量）赋值给变量
n1 = 100
f1 = 47.5
s1 = "http://c.biancheng.net/python/"

#将一个变量的值赋给另一个变量
n2 = n1
f2 = f1

#将某些运算的值赋给变量
sum1 = 25 + 46 
sum2 = n1 % 6
s2 = str(1234)  #将数字转换成字符串
s3 = str(100) + "abc"

连续赋值

Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：

a = b = c = 100

= 具有右结合性，我们从右到左分析这个表达式：

• c = 100 表示将 100 赋值给 c，所以 c 的值是 100；同时，c = 100 这个子表达式的值也是 100。
• b = c = 100 表示将 c = 100 的值赋给 b，因此 b 的值也是 100。
• 以此类推，a 的值也是 100。

最终结果就是，a、b、c 三个变量的值都是 100。

= 和 ==

= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。

扩展后的赋值运算符

= 还可与其他运算符（包括算术运算符、位运算符和逻辑运算符）相结合，扩展成为功能更加强大的赋值运算符，如表 1 所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。

这里举个简单的例子：

n1 = 100
f1 = 25.5

n1 -= 80  #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )

print("n1=%d" % n1) # 20
print("f1=%.2f" % f1) # 255.00

通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。

但是请注意，这种赋值运算符只能针对已经存在的变量赋值，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：

n += 10

该表达式等价于 n = n + 10，n 没有提前定义，所以它不能参与加法运算。

位运算符

Python 位运算按照数据在内存中的二进制位（Bit）进行操作，它一般用于底层开发（算法设计、驱动、图像处理、单片机等），在应用层开发（Web 开发、Linux 运维等）中并不常见。想加快学习进度，或者不关注底层开发的读者可以先跳过本节，以后需要的话再来学习。这里了略过

比较运算符

比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。

Python 支持的比较运算符如下

== 和 is 的区别

初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。

== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象，例如：

import time  #引入time模块

t1 = time.gmtime() # gmtime()用来获取当前时间
t2 =  time.gmtime()

print(t1 == t2) #输出True
print(t1 is t2) #输出False

Time 模块的 gmtime () 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。

虽然 t1 和 t2 的值相等，但它们是两个不同的对象（每次调用 gmtime () 都返回不同的对象），所以 t1 is t2 返回 False。这就好像两个双胞胎姐妹，虽然她们的外貌是一样的，但它们是两个人。

那么，如何判断两个对象是否相同呢？答案是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了；这就像两个名字使用了同一个身体，当然就是同一个人了。

逻辑运算符

高中数学中我们就学过逻辑运算，例如 p 为真命题，q 为假命题，那么“p 且 q”为假，“p 或 q”为真，“非 q”为真。Python 也有类似的逻辑运算，请看下表：

逻辑运算符一般和关系运算符结合使用，例如：

14>6 and 45.6 > 90

Python 逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。请看下面的例子：

print(100 and 200) # 200
print(45 and 0) # 0
print("" or "http://c.biancheng.net/python/") # http://c.biancheng.net/python/
print(18.5 or "http://c.biancheng.net/python/") # 18.5

上例中的执行结果可以用短路原理来解释。

in 和 not in

in 与 not in 操作符， 可以判定一个值是否在列表中。

books = ['梦的化石', '冬泳', '鱼翅与花椒']
new_book = '莫斯科绅士'
if '莫斯科绅士' not in books:
    print(new_book + '不在书单中，现在添加……')
    books.append(new_book)
if '莫斯科绅士' in books:
    print(new_book + '已经在书单中。')

print('books = ' + str(books))

字符串也可以利用 in 与 not in 操作符来判断某个字符是否存在：

is_exist = '绅士' in '莫斯科绅士'
print(is_exist)

is_exist = '科' in '莫斯科绅士'
print(is_exist)

is_not_exist = '冬泳' not in '莫斯科绅士'
print(is_not_exist)

字典的 key 也可以判断

data = {
    'zh-cn': "中文简体",
    'zh-tw': "中文繁体",
}
language = data['zh-cn'] if 'zh-cn' in data and data['zh-cn'] else '暂无语言'
print(language)  # 中文简体

运算符的优先级

Python 支持几十种运算符，被划分成将近二十个优先级，有的运算符优先级不同，有的运算符优先级相同，请看下表。

结果表中的运算符优先级，我们尝试分析下面表达式的结果：

4+4<<2

+ 的优先级是 12，<< 的优先级是 11，+ 的优先级高于 <<，所以先执行 4+4，得到结果 8，再执行 8<<2，得到结果 32，这也是整个表达式的最终结果。

当然，我们也可以使用 ( ) 改变程序的执行顺序，比如：

4+(4<<2)

则先执行 4<<2，得到结果 16，再执行 4+16，得到结果20。

运算符的结合性

谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。

例如对于表达式对于100 / 25 * 16，/和*的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/和*都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。

Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。