Python之旅-3

前言：

本篇文章是《Python之旅》系列的第三篇，在上一篇文章中主要学习了：Python的变量、多变量以及Python的五种数据类型。本篇文章主要学习的知识点有：Python的常见运算符，包括：算术操作符、比较操作符、赋值操作符、成员操作符、身份操作符以及运算符的优先级

Python的算术运算符：

算术运算符是指对变量进行算术操作的运算，比如常见的加减乘除等等（加减乘除这里就不写例子了） Python的算术运算符还包括：

• 取模运算符 （使用符号：%）
• 次幂运算符 （使用符号：**）
• 取整运算符 （使用符号：\）
  参考代码如下：

a = 3
b = 2

x = a % b
# 返回除法的余数 3/2  取模余 1
print "a % b 的值为：", x

y = a ** b
#等价于3 的 b 次方 也就是 9
print "a ** b 的值为：", y

z = a // b
# 取整除 返回商的整数部分
print "a // b 的值为：", z

运行结果如下：

a % b 的值为： 1
a ** b 的值为： 9
a // b 的值为： 1

可能对取模和取整的运算有些不好理解，下面就增加一个代码截图方便进一步的了解：

取模和取整

Python的比较运算符：

所谓的比较运算符，就是比较a b两个的关系(是相等、是大于还是小于)，返回值是true或者false，常见的比较运算符有以下几种：

• 大于运算符（使用符号：>）
• 小于运算符（使用符号：<）
• 相等运算符（使用符号：==）
• 不等运算符（使用符号：<>）
• 不等运算符（使用符号：!=）
• 大于等于运算符（使用符号：>=）
• 小于等于运算符（使用符号：<=）

其中，不等运算符有2种表现形式，一种是习惯的用!=来表达不等运算符，还有一种是使用<>，这个是要值得注意的，代码如下：

a = 5
b = 2
# - 大于运算符（使用符号：>）
print "a > b == ", a > b

# - 小于运算符（使用符号：<）
print "a < b == ", a < b

# - 相等运算符（使用符号：==）
print "a < b == ", a == b
# - 不等运算符（使用符号：<>）
print "a <> b == ", a <> b

# - 不等运算符（使用符号：!=）
print "a != b == ", a != b

# - 大于等于运算符（使用符号：>=）
print "a >= b == ", a >= b

# - 小于等于运算符（使用符号：<=）
print "a <= b == ", a <= b

运行结果如下：

a > b ==  True
a < b ==  False
a < b ==  False
a <> b ==  True
a != b ==  True
a >= b ==  True
a <= b ==  False

Python的赋值运算符：

所谓的赋值运算符，实际就是将值通过计算（或者不计算）来赋值给另外一个变量，比如，常见的 = 号，就意味将右边的结果赋值给左边的变量。假设现在有3个变量，分别为a b c，在Python中，常见的赋值运算符有以下几种：

• 直接赋值运算符（使用符号：=）如：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
  下面是赋值运算符的参考代码：

# 赋值运算符：
a = 2
b = 3
c = 4
# - 直接赋值运算符（使用符号：=）如：c = a + b ，就是将 a + b 的结果赋值给 c
print "c = ", a + b

# - 加法赋值运算符（使用符号：+=）如：c += a 等价于 c = c + a
print "c += a = ", c + a

# - 减法赋值运算符（使用符号：-=）如：c -= a 等价于 c = c - a
print "c -= a = ", c - a

# - 乘法赋值运算符（使用符号：*=）如：c *= a 等价于 c = c * a
print "c *= a = ", c * a

# - 除法赋值运算符（使用符号：/=）如：c /= a 等价于 c = c / a
print "c /= a = ", c / a

# - 取模赋值运算符（使用符号：%=）如：c %= a 等价于 c = c % a
print "c %= a = ", c % a

# - 幂赋值运算符（使用符号：**=）如：c ** a 等价于 c = c 的 a 次方
print "c ** a = ", c ** a

# - 取整除赋值运算符（使用符号：//=）如：c //= a 等效于 c = c // a
print "c // a = ", c // a

运行结果如下：

c =  5
c += a =  6
c -= a =  2
c *= a =  8
c /= a =  2
c %= a =  0
c ** a =  16
c // a =  2

Python的成员运算符：

所谓的成员运算符，就是可以判断一个元素是否在某一个序列中，比如可以判断一个字符是否属于这个字符串，可以判断某个对象是否在这个列表中等等。Python使用关键字in not in，来表达成员运算符。其中，in表达的意思是：如果在指定的序列中找到该值,则返回 True，否则返回 False； not in表达的意思是：如果在指定的序列中没有找到该值，则返回 True，否则返回 False。参考代码如下：

a = 2
b = 6
listData = [1, 2, 3, 4, 5]
if( a in listData ):
    print "in语句 - a在该范围之内"
else:
    print "in语句 - a不在该范围之内"

if( b in listData ):
    print "in语句 - b在该范围之内"
else:
    print "in语句 - b不在该范围之内"

if( a not in listData ):
    print "not in语句 - a不在该范围之内"
else:
    print "not in语句 - a在该范围之内"

if( b not in listData ):
    print "not in语句 - b不在该范围之内"
else:
    print "not in语句 - b在该范围之内"

运行结果如下：

in语句 - a在该范围之内
in语句 - b不在该范围之内
not in语句 - a在该范围之内
not in语句 - b不在该范围之内

Python的身份运算符：

身份运算符主要是用于比较两个对象的存储单元，也就是变量所在的内存地址是否相等。Python使用关键字is is not，来表达身份运算符。
其中，is表达的意思是：判断两个标识符是不是引用自一个对象，如果引用的是同一个对象，则返回 True、否则返回 False；not is表达的意思是：是判断两个标识符是不是引用自不同对象，如果引用的不是同一个对象，则返回结果 True、否则返回 False。参考代码如下：

a = 520
b = 520
if( a is b ):
    print "is语句 - a true b"
else:
    print "is语句 - a false b"

if( a is not b ):
    print "is not语句 - a和b不是同一个引用"
else:
    print "is not语句 - a和b是同一个引用"

运算结果如下：

is语句 - a true b
is not语句 - a和b是同一个引用

注意：Python解释器判断2个变量属性值是否一样，使用的是 == 号；然后Python获取变量的地址值是使用id(变量)这个函数，因此，a is b 其实也就等同于 id(a) == id(b)。老司机可能会问道，既然是a b 2个不同的变量，那么就在内存中开辟了2块空间，那为什么a b 的地址值会相等？经过查阅得出的结论如下：
Python出于对性能的考虑，但凡是不可变对象，在同一个代码块中的对象，只有是值相同的对象，就不会重复创建，而是直接引用已经存在的对象，通过打印地址值发现：声明不同的变量但属性相同，变量的地址值是一样的：

打印地址值

Python的运算符优先级：

如数学中的运算符一样，Python的运算符也是有优先级的。Python的优先级执行顺序是：幂次方运算优先级最高、其次是乘除取模和取整除、然后再是加减法，有括号的优先计算括号内的表达式，下面是参考代码：

a = 2.0
b = 3.0
c = 4.0
d = 5.0

e = (a + b) * c / d
print "(a + b) * c / d 运算结果为：", e

e = ((a + b) * c) / d
print "((a + b) * c) / d 运算结果为：", e

e = (a + b) * (c / d)
print "(a + b) * (c / d) 运算结果为：", e

e = a + (b * c) / d
print "a + (b * c) / d 运算结果为：", e

e = ( a**b + a ) / d
print "( a**b + a )/ d 运算结果为：", e

e =  a**b + c / a
print " a**b + c / a 运算结果为：", e

运行结果如下：

(a + b) * c / d 运算结果为： 4.0
((a + b) * c) / d 运算结果为： 4.0
(a + b) * (c / d) 运算结果为： 4.0
a + (b * c) / d 运算结果为： 4.4
( a**b + a )/ d 运算结果为： 2.0
 a**b + c / a 运算结果为： 10.0

总结：

本篇文章主要学习了Python的几种常见运算符，具体的内容有Python的算术操作符、比较操作符、赋值操作符、成员操作符、身份操作符以及运算符的优先级

如果这篇文章对您有开发or学习上的些许帮助，希望各位看官留下宝贵的star，谢谢。

Ps:著作权归作者所有,转载请注明作者, 商业转载请联系作者获得授权，非商业转载请注明出处(开头或结尾请添加转载出处，添加原文url地址),文章请勿滥用,也希望大家尊重笔者的劳动成果