算数运算符
符号意义
以下是常用的算数运算符：
符号 | 意义 |
+ | 加法运算 |
- | 减法运算 |
* | 乘法运算 |
/ | 除法运算，精确除法（返回float） |
// | 除法运算，地板除法（向下取整，生成int） |
** | 幂运算 |
% | 求余运算 |
注意事项：
- float与int或者bool做运算，得到的结果均为float
>>> 1 + 1.0
2.0
>>> 1 - 1.0
0.0
>>> 1 * 1.0
1.0
>>> 1 / 1.0
1.0- **幂运算仅支持int 、float、 bool 三种类型
>>> 2 ** 3
8
>>> 2.0 ** 3
8.0
>>> True ** 3
1
>>>- %求余运算只支持 int 、float、 bool 三种类型，如果被求余数小于求余数，那么余数就为被求余数本身
>>> 6 % 8
6示例演示
加法运算
print(1 + 1)
print(1 + 1.1)
print(1 + True)
print([1, 2, 3] + [4, 5, 6])
print('OldStr ' + ' NewStr') # Change the reference value, generate new objects
print((1, 2, 3) + (4, 5, 6)) # Change the reference value, generate new objects
# 2
# 2.1
# 2
# OldStr NewStr
# [1, 2, 3, 4, 5, 6]
# (1, 2, 3, 4, 5, 6)减法运算
print(1 - 1)
print(1 - 1.1)
print(1 - True)
# 0
# -0.10000000000000009
# 0乘法运算
s1 = '￥'
l1 = [1, 2, 3]
t1 = (1, 2, 3)
print(1 * 2)
print(1 * 2.0)
print(1 * True)
print(3 * l1)
print(3 * s1) # Change the reference value to generate a new STR object
print(3 * t1) # Change the reference value to generate a new Tuple object
# 2
# 2.0
# 1
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
# ￥￥￥
# (1, 2, 3, 1, 2, 3, 1, 2, 3)精确除法
print(10 / 2)
print(10 / 2.0)
print(10.1 / True)
print(10.1 / True)
print(10.1 / True)
print(10.1 / True)
print(False / 10)
print(True / 2)
print(True / 2.0)
# 5.0
# 5.0
# 10.1
# 10.1
# 10.1
# 10.1
# 0.0
# 0.5
# 0.5赋值运算符
符号意义
以下是常用的赋值运算符：
符号 | 意义 |
= | 普通的赋值 |
+ | 增量加法赋值 |
- | 增量减法赋值 |
* | 增量乘法赋值 |
/ | 增量精确除法赋值 |
// | 增量地板除法赋值 |
** | 增量幂运算赋值 |
% | 增量求余赋值 |
普通赋值
赋值运算符为=，切记一个=才是赋值：
>>> x = 1
>>> x
1增量赋值
在原本标识符所指向的对象基础上进行增量的运算后，再将运算结果赋值给原本的标识符。
增量赋值运算符就是将赋值符号和算术运算符结合起来达到简写的目的：
普通的先运算后赋值：
>>> x = 1
>>> x = x + 10
>>> x
11
>>> x = x - 10
>>> x
1
>>> x = x * 10
>>> x
10
>>> x = x / 10
>>> x
1.0
>>> x = x // 10
>>> x
0.0
>>> x = x ** 10
>>> x
0.0
>>> x = x % 10
>>> x
0.0简便的增量运算符：
>>> x = 1
>>> x += 10
>>> x
11
>>> x -= 10
>>> x
1
>>> x *= 10
>>> x
10
>>> x /= 10
>>> x
1.0
>>> x //= 10
>>> x
0.0
>>> x **= 10
>>> x
0.0
>>> x %= 10
>>> x
0.0平行赋值
平行赋值，一次为多个标识符进行赋值：
>>> x, y, z = 1, 2, 3
>>> x
1
>>> y
2
>>> z
3链式赋值
链式赋值，多个标识符引用同一个对象：
>>> x = y = z = "Object"
>>> x
'Object'
>>> y
'Object'
>>> z
'Object'链式赋值也被称之为间接赋值。
交叉赋值
交叉赋值，将2个标识符所指向的对象进行互换：
>>> x = "Object001"
>>> y = "Object002"
>>> x, y = y, x
>>> x
'Object002'
>>> y
'Object001'解压赋值
解压赋值这里不再进行赘述了，前面在介绍内置数据类型的时候已经介绍过了。
比较运算符
符号意义
比较运算符的返回结果总是为True或者False，一般是用于比较2个相同类型的值的大小。
常用于条件分支结构中：
符号 | 意义 |
> | 大于 |
< | 小于 |
== | 等于 |
!= | 不等于 |
>= | 大于或者等于 |
<= | 小于或者等于 |
示例演示
比较运算符得到的结果必然是bool类型：
>>> 1 < 2
True
>>> 1 > 2
False
>>> 1 == 1.0
True
>>> 1 == True
True比较方式
字符串与字符串之间的比较会一位一位对照ASCII表来进行比对：
>>> ord("y")
121
>>> ord("k")
107
>>> "y" > "k"
True如果是非ASCII字符，则会调用其他的比较机制，如调用locale模块下的strxfrm()函数对字符串进行本地化处理：
print("中" > "美")如果是数字串，则会一位一位进行比较：
>>> "100" > "4"
False
# 第一位比较：1 小于 4，后续不再比较数字与数字之间的比较会之间比较整体：
>>> 100 > 1000
False元组、列表之间的比较会根据相同的索引值进行一位一位的比较：
>>> ("100", ) > ("45", "b")
False
# 1比4小逻辑运算符
逻辑词汇
不同于其他编程语言的&&和||，Python中使用单词代表与或非。
单词 | 意义 |
not | 非，统一取反 |
and | 与，一真一假取一假，两个为真才取真 |
or | 或，一真一假取一真，两个为假才取假 |
优先级
优先级的意思是如下：
not True and False or True # 第一个True是该给not还是and做运算呢？牢记：NOT>AND>OR
故上面的结果为：
True以下是推算流程：
False and False or True
False or True
True示例演示
使用not进行取反：
>>> not 1 > 2
True使用and进行多条件连接：
>>> name = "Yunya"
>>> age = 18
>>> name == "Yunya" and age == 18
True
>>>使用or进行或逻辑判断：
>>> name = "Yunya"
>>> age = 18
>>> name == "Yunya" or age == 100
True
>>>短路运算
如果一次逻辑运算中的逻辑运算符号全部为 and 或者 or 则会从左至右依次进行逻辑运算。
如果每一次都进行运算是很消耗时间的，所以这个时候出现了短路机制。
看图说话：
与或运算
如果不是对True或者False进行and or运算而是对数字进行and or运算呢？
只需要牢记0是False非0是True即可：
>>> 1 and 0 or 3
3
>>> 3 + 1 and 4 or 0
4每次的结果，都取最后一个True值：
>>> 1 and 2
2
>>> 2 and 1
1
>>> 1 or 0
1
>>> 0 or 1
1成员运算符
in
in用来判断容器类型的某一个数据项是否在其中，支持的类型有str、list、tuple、dict、set、frozenset，所有的判定严格区分大小写。
- in：在其中
- not in：不在其中
需要注意的是如果是对dict做in的成员判定，只会判定key是否在其中：
>>> string = "ABCDEFG"
>>> "A" in string
True
>>> "a" in string
False
>>> li1 = [1, 2, 3]
>>> 1 in li1
True
>>> 0 in li1
False
>>> tup = (1, 2, 3)
>>> 1 in tup
True
>>> 0 in tup
False
>>> dic = {"k1" : "v1", "k2" : "v2"}
>>> "k1" in dic
True
>>> "v1" in dic
False
>>> s1 = {1, 2, 3}
>>> 1 in s1
True
>>> 0 in s1
False身份运算符
is
is判定对象是否来自同一引用，即是否是同一个对象，用来判断引用是否相等：
>>> x = y = z = "I love Python"
>>> x is y
True
>>> x is z
Trueis&==的异同
==仅判断对象的值是否相同，不关心是否引用自同一对象：
>>> x = "I love Python"
>>> y = "I love Python"
>>> x == y
True
>>> x is y
False两者的区别在于使用is时相当于使用 id(obj) == id(obj)，即对象是否为同一引用：
>>> x = "I love Python"
>>> y = "I love Python"
>>> id(x)
4305667952
>>> id(y)
4305668016
>>> id(x) == id(y) # is
False而==则不会判定id，仅判断2个对象的形式值是否相同：
>>> x = "I love Python"
>>> y = "I love Python"
>>> id(x)
4305667952
>>> id(y)
4305668016
>>> x == y
True小结：
- is：引用判定，引用相等的对象则必然值相等
- ==：值判定，值相等的对象引用不一定相等
is None
一般来说，我们对None做判断时都会使用is None而不是 == None，这是因为None本身就是一个单例对象。
所有的None对象其实内部都引用自同一对象，在PEP8规范中明确表示，对于None的判定应该使用is而不是==：
r = None
print(r is None)
print(r == None)
# True
# True虽然这么使用毫无问题，但是在PyCharm中会报出PEP8不规范的提示：
对象的增量与普通运算操作
记住一句话，增量是原地操作，不会开辟新的内存空间（字符串的+=除外）。
而普通的运算操作则会开辟新的内存空间，返回1个新对象。
我们以列表举例：
>>> lst1 = [1, 2, 3]
>>> lst2 = lst1 * 3
>>> lst1 is lst2
False
>>> lst2
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> lst1 = [1, 2, 3]
>>> id(li1)
4346207752
>>> lst1 *= 3
>>> id(li1)
4346207752
>>> lst1
[1, 2, 3, 1, 2, 3, 1, 2, 3]
