第四章：运算符

1.算数运算符

1.1.什么是运算符？

运算符用于执行程序代码运算，会针对一个以上操作上来进行运算。
例如：2 + 3 ，其操作数是2和3，二运算符则是"+"

1.2算数运算符表现形式有+ - * / //

** %
1.如果是两个字符串相加，则会进行拼串操作

x = 'Logic'+ ' '+'Python'
print('x = ',x)
>>>x =  Logic Python

2.如果两个字符串相乘，则会对字符串进行复制操作，将字符串重置制定次数

3.除法运算符总会返回一个类型的值

4.//取整除运算 只会保留计算机的整数位，总会返回一个整型

取整除运算就是取商的值 6 / 4 = 1.。。。。。。2（取值为1）

5 . 取模运算 % 求两个数相除的余数
取模运算就是取余数 6 / 4=1.。。。。。。2（取值为2）

6.幂运算 ** 求一个值的几次幂（几次方）

7.开平方运算 也会返回一个浮点型(开0.5次幂）
x = 25**0.5

2.赋值运算符

a = 10
30 = b(不行） 3 = 4（不行）
+= >>> x += 3——>相当于 x = x + 3
-= >>> x -= 3——>相当于 x = x - 3
*= >>> x *= 3 ——>相当于 x = x + 3
/=>>> x /= 3 ——>相当于 x = x / 3
//= >>> x //=3 ——>相当于 x = x // 3
%=>>> x %=3——>相当于 x = x % 3
** = >>> x **=3——>相当于 x = x **3

x = 2
x += 3   #5
x -= 3   #2
x *= 3   #6
x /= 3   #2.0
x //= 3  #0.0
x = 5
x %= 2   #1
print('x = ',x)

3.比较运算符

比较运算符就是用来比较两个值之间的关系，总会返回一个布尔值

比较左侧值是否大于右侧值
= 比较左侧值是否大于 或者等于右侧值
< 比较左侧值是否小于左侧值
<= 左侧值是否小于或者等于右侧值

# 比较运算符
r = 10 > 20  # False
r = 30 > 20  # True
r = 30 < 20  # False
r = 20 >= 20  # True

r = 3 > True  # 3 > 1

r = '2' > '1'  # True
r = '2' > '11' # True

r = 'a' > 'b'  #False
r = 'c' < 'd'   #True

r = 'ab' > 'b'  #False  #只用比较 a 和 b的大小
#如果出现多个字符那么我们比较的方式是对位比较

如果我们想比较id 怎么办？
可以用到 is 和 is not

is ：比较两个对象是否是一个对象， 比较的是对象的id
is not :比较两个对象是否不是同一个对象，比较的是对象的id

r = 3 == 3 #True
r = 'Python' == 'Python'  #True
r = 'bcd' == 'abc'            #False
r = 1 == True                 #True

r = 0 is False                # False
r = 1 is not True           #False

>>> a = 'Jerry Python'
	  
>>> max(a)
	  
'y'
>>> min(a)
	  
' '
>>> ord('y'),ord(' ')
	  
(121, 32)
>>> 1 == True
	  
True
>>> id(1),id(True)
	  
(1831431184, 1830940896)
>>> 0 == False
	  
True
>>> 1 = False
	  
SyntaxError: can't assign to literal
>>> 0 = False
	  
SyntaxError: can't assign to literal
>>> 1 = True
	  
SyntaxError: can't assign to literal
>>> 0 == False
	  
True
>>> 1 == True
	  
True
>>> r = 'bcd' == 'abc'
	  
>>> r
	  
False
>>> r = 0 is False
	  
>>> r
	  
False
>>> r = 1 is not True
	  
>>> r
	  
True
>>> r = 9 is not True
	  
>>> r
	  
True
>>> r = 11 is not False
	  
>>> r
	  
True
>>> False is not True
	  
True
>>> False is True
	  
False
>>> 'abc' is not 'def'
	  
True
>>> 'abc' is 'def'
	  
False
>>> 0 == True
	  
False

4.逻辑运算符

x > 1 and x > 2

not ：逻辑非
可以对符号右侧的值进行非运算
对于布尔值，非运算会对其进行取反运算 True ——> False, False——>True
对于非布尔值，会先将其转换为布尔值，然后再取反
例如： 0 空串 None 还有一些其他是空性的值会转换成False，剩下的都是True

a = True
a = not a
a = None # False  #对于非布尔值，会先将其转换为布尔值，然后再取反
a = not a  # True

and ： 逻辑与（找False，找到了就返回False，没找到就输出第二个字符串）
1.（看第一个字符串是否是False，如果是就直接返回第一个值，如果不是就直接返回第二个值）
2.可以对符号两侧的值进行与运算
3.只有在符号两侧都是True的情况下才会返回True， 只要有一个False就会返回False（说白了与运算就是找False）

r = True and True   # True
r = True and False  # False
r = False and True  # False
r = False and False # False

True and print('Hello')       # Hello  (找False，第一个不是False，就直接返回第二个值）
False and print('Hello')      # 空值   （找False，第一个值是False，就直接返回第一个值）

or ：逻辑或（找True，找到了就返回True，没找到就输出第二个字符串）
1.（看第一个字符串是否是False，如果是就直接返回第一个值，如果不是就直接返回第二个值）
2.or 可以对符号两侧的值进行或运算
3.或运算两个值只要有一个True，就会返回True，或运算就是找True（返回True，打印出来就是什么都没有）

r = True or True       # True 
r = True or False      # True
r = False or True      # True
r = False or False     # False

True or print('Hello')        # 空值
False or print('Hello')       # Hello

非布尔值的与或运算
当我们对非布尔值进行或运算的时候，Python会将其当作布尔值进行运算，最终会返回原值

#   True  True
r = 1 and 2  # 2

#   True  True
r = 1 and 2      # 2

r = 1 and 0      #  0

r = 0 and None   #  0 

与运算的规则
与运算找False，如果第一个值是False，就直接返回第一个值，不看第二个值
如果第一个值不是False，则直接返回第二个值。

或运算的规则
或运算就是找True，如果第一个值是True，就直接返回第一个值，则不看第二个值，如果第二个值是False，则返回第二个值。

r = 1 or 2       # 1

r = 1 or 0       # 1
r = 0 or 1       # 1
r = None or 0    # 0

r = 1 < 2 < 3  # 1 < 2 and 2 < 3

5.条件运算符

条件运算符（三元运算符）
语法：语句1 if 条件表达式 else 语句2

print('Python') if True else print('Java')
>>>Python

a = 30
b = 40
print('a的值大') if a > b else print('b的值大')
>>>b的值大

a = 60
b = 40
max = a if a > b else b
print(max)
>>>60

# 现在有 a b c三个变量  请通过条件运算符获取三个值当中的最大值
a = 10
b = 20
c = 30

max = a if a > b else b
max = max if max > c else c
print(max)
>>>30

# 一次性比较出来大小
a = 10
b = 50
c = 30

max = a if (a > b and a > c) else (b if b > c else c)
print(max)

6. 运算符的优先级

在Python中and的优先级大于or
运算符的优先级可以根据表格来查询，规则：优先级越高越优先计算，如果优先级一样，就从左往右依次计算：Python官网——>Documentation——>Python 3.X Docs——>Language Reference ——>Expressions——>Operator precedence

a = 2 or 3 and 4  # 结果为2（在Python中and的优先级大于or）
# or 和 and 优先级一样 从左往右运算  结果 4
# or 优先级高 结果 4
# and 优先级高 结果 2

a = not 4 > 2 and 5 > 6 or 3 < 4  # True ——>not T and F or T——>F or T——>T
a = not (4 > 2 and 5 > 6 or 3 < 4)  # False——>not(T and F or T)——>not(F or T)
# ——>not T——>False
#优先级大小： not > and > or
#4 > 2——>True  not True——>False ; 5 > 6——>False ;3 < 4——>True ; False and False or True ——>True
print(a)