算数运算符

算数运算符主要用作于计算机的算数运算

种类符号作用+加法、字符串的拼接

-减法

*乘法、字符串的重复

/除法

//地板除(除法)

%取余(除法)

**幂运算

+# 数字类型的加法运算

print(1 + 1)                # 2

print(False + 1)            # 1

print(0j + 1)               # (1+0j)

# 字符串的拼接

var1 = 'hello'

var2 = 'motherland'

print(var1 + ' ' + var2)    # hello motherland

*# 数字类型的乘法运算

print(1 * 1)                # 1

print(False * 1)            # 0

print(0j * 1)               # 0j

# 字符串的重复

var1 = 'hello'

print(var1)                 # hello

print(var1 * 2)             # hellohello

print(var1 * 3)             # hellohellohello

/# 数字类型的除法运算，结果总是小数，至少返回一位小数

print(1 / 1)                # 1.0

print(False / 1)            # 0.0

# print(False / False)        # 除数不能为0

print(10 / 5)               # 2.0

print(10 / 3)               # 3.3333333333333335

print(10 / 2.25)            # 4.444444444444445

//# 数字类型的除法运算

# // 的运算结果只有在除数或者是被除数为小数的时候才是小数，并且永远是一位小数，小数位为0

print(1 // 1)                # 1

print(100 // 5)              # 20

print(10.9 // 1)             # 10.0

print(10 // 1.5)             # 6.0

print(10.5 // 1.1)           # 9.0

print(10.0 // 3)             # 3.0

%# 不会将数除尽，求出除法中的余数

print(10 % 3)       # 1

# 如果被除数和除数都是负数，余数是正常余数取反

# 如果除数是负数，余数是正常余数+除数

# 如果被除数是负数，余数就是第二种情况的取反

print(10 % 3)       # 1

print(-10 % -3)       # -1

print(10 % -3)       # -2

print(-10 % 3)       # 2

print(11 % 4)       # 3

print(-11 % -4)     # -3

print(11 % -4)      # -1

print(-11 % 4)      # 1

print(15 % 6)       # 3

print(-15 % -6)     # -3

print(15 % -6)      # -3

print(-15 % 6)      # 3

**# 求一个数的幂次方

print(2 ** 1)       # 2

print(2 ** 2)       # 4

print(2 ** 3)       # 8

print(2 ** 4)       # 16

-# 数字类型的减法运算

print(1 - 1)                # 0

print(False - 1)            # -1

print(0j - 1)               # (-1+0j)

比较运算符

概念比较两个值是否相同，结果只会是布尔值，条件成立返回True，反之False;

可以比较任何类型的数据；

python没有向其它语言中一样区分等于和绝对等于的概念，等于就是绝对等于，是区分数据类型的；

种类符号作用>大于

>=大于等于

<=小于等于

==等于

!=不等于print(1234 == '1234')       # False

print(1234 == 1234)         # True

赋值运算符

概念给某个数据赋予新的值

除了=之外的其它赋值运算符，都是在算数运算符的基础上添加了=，使用的方法则和原有的意义基本相同，是将算数出来的结果替换原有的数据

比较两个值是否相同，结果只会是布尔值，条件成立返回True，反之False;

python没有其它语言的自增和自减概念；

种类符号作用=赋值

+=运算替换

-=运算替换

*=运算替换

/=运算替换

//=运算替换

%=运算替换

**=运算替换# 直接赋值

var = 'msr'

print(var)      # msr

var = 'hello'

print(var)      # hello

# 通过算数运算得出结果，然后替代原有的数据

var *= 3

print(var)      # hellohellohello

成员运算符

作用

用于针对容器型数据，查询某个数据是否是容器当中的元素；返回布尔值，条件成立返回True，反之False；

种类符号作用in查询的元素是否在容器当中

not in查询的元素是否不在在容器当中

字符串# 只可以连续的元素，就是说不支持模糊查询

var = '你是Java的大神，他是PHP的开发者，我是Python的小白。'

print('Java的大神' in var)         # True

print('Python的小白' not in var)   # False

字典# 在字典当中只会判断键，不会判断值

var = {'及时雨': '宋江', '玉麒麟': '卢俊义'}

print('及时雨' in var)  # True

print('宋江' in var)  # False

身份运算符

作用

检测两个数据在内存当中是否是同一个值，返回布尔值

种类符号作用is是同一地址

is not不是同一地址

Python的内存优化整型：-5 ~~ 正无穷的范围内的数内存地址相同

浮点型：非负数的内存的地址相同

布尔型：同值内存地址相同

复数：实数+虚数的的格式永不相同

容器类型：只有字符串和空元组的情况相同intvar = 100

strvar = 'hello'

# 利用id()函数检查是否是同一地址

res = id(intvar) == id(strvar)

print(res)      # False

# 使用身份运算符

res = intvar is strvar

print(res)      # fasle

逻辑运算符

作用

判断运算符两边的布尔值，返回布尔值

种类符号作用特点and逻辑与：两遍的数据都为真，返回True全真为真，一假则假

or逻辑或：两遍的数据有一个为真，返回True全假为假，全假为假

not逻辑非：将后面的数据的逻辑值反转真为假，假为真

and——逻辑与运算符两遍的值都为真，返回真，其余情况返回假# 为真的概率低

res = True and True# True

res = True and False# False

res = False and True# False

res = False and False# False

or——逻辑与运算符两遍的值都为假，返回假，其余情况返回真# 为假得概率低

res = True or True# True

res = True or False# True

res = False or True# True

res = False or False# False

not——逻辑非将左侧的进行反转，真的转为假，假的转为真res = not True# False

res = not False# True

布尔值为假的十种情况还记得吗？？？0     0.0      0j      False     ""      []      ()       set()     {}      None

逻辑短路True or 表达式

False and 表达式

在逻辑表达式中，or的特点是一真则真，所以True or首先是发现前面已经有了真，所以or就无需再检查后面的数据是真是假，直接返回前面的真，导致不在执行后面的代码，造成逻辑短路。

False and同理，and一假则假，所以当and前面出现假的时候，就不在需要知道后面的数据是真是假，直接返回假，造成逻辑短路。# 逻辑短路，不会执行后面的print函数

True  or  print('hello world')

False and print('hello world')

# 没有短路

False  or  print('hello world')

True   and print('hello world')

逻辑运算符的优先级()   >   not    >    and     >     or

和数学的运算一样，要先运算括号内的数据。

在多逻辑运算符的算数中，按照优先级计算。0 or 6 and not 9 and (1 or 3)

# 按照优先级依次运算，得出结果为False

位运算符

作用

位运算符用二进制数补码进行运算

种类符号作用&按位与

|按位或

~按位非

^按位异或

<

>>右移位

&(按位与)

将数字的补码中，同位数都为真的保留下来，组合成新数字19的补码：                             0000 ... 10011

15的补码：                             0000 ... 01111

同位数都为真的保留下来：  0000 ... 00011  =>  3print(15 & 19)

|(按位或)

将数字的补码中，同位数只要有一个为真就保留下来，组合成新数字19的补码：                                 0000 ... 10011

15的补码：                                 0000 ... 01111

同位数一个为真的保留下来：  0000 ... 11111  =>  31print(15 | 19)

^(按位异或)

将数字的补码中，同位数相同返回假，不同返回真，组合成新数字19的补码：                     0000 ... 10011

15的补码：                     0000 ... 01111

同位数不同的返回真：  0000 ... 11100  =>  28print(15 ^ 19)

<

整个数字向左移位，原位补0，组合成新数字

左移位相当于做乘法，左移n位，就相当于乘 2 的n次幂19的补码：0001  0011

左移1位：  0010  0110  =>  38print(19 <

>>(右移位)

整个数字向右移位，原位补0，溢出消失，组合成新数字

右移位相当于做除法，左移n位，就相当于除以 2 的n次幂19的补码：0001 0011

右移1位：  0000 1001   =>  9print(19 >> 1)

~ 按位非

按位取反，包括符号位。

公式：-(n + 1)十进制数：19

原码：    0001 0011

反码：    0001 0011

补码：    0001 0011(先得到一个数的补码)

按位非：1110 1100(按位非，包括符号位在内的全部取反)

补码：    1110 1100(结果还是补码)

取反：    1001 0011

原码：    1001 0100 (根据这个补码还原的原码)

十进制数：-20-(19 + 1) = -20print(~19)

运算符总结：

运算符种类算术运算符：      +      -      *      /      //      %      **

比较运算符：      >      <      >=      <=      ==      !=

赋值运算符：      =      +=      -=      *=      /=      //=      %=      **=

成员运算符：      in     、  not in

身份运算符：      is     、  is not

逻辑运算符：      and   、   or  、    not

位运算符：          &      |      ^      ~      <<      >>

运算符优先级

权重从小之下当多种运算符混合使用：

算数      >      位      >      比较      >      身份      >      成员      >      逻辑      >      赋值

一元运算符      >      二元运算符

一元运算符：同一时间只操作一个值，比如按位非(~19)、逻辑非(not True)

二元运算符：同一时间操作两个值，多数是这样的，比如幂运算(2 ** 3)、逻辑与(True and False)

算数运算符：

幂运算      >      乘除      >      加减

位运算符：

按位非      >      左右移      >      按位与      >      按位异或      >      按位或

逻辑运算符：

()      >      not      >      and      >      or

赋值运算符：

= 最小

小经验

这是我的一点心得：

写出机器看得懂的代码是行业门榄，质量高的代码是行业的水准，让人看得懂的代码是行业的标杆。一个优秀的编程工作者写的代码会看起来更加的直观。

在编写复杂的运算式的时候要注意尽量的让代码直观，比如可以使用括号。下面的两行运算式的结果一样，但是给人的截然不同。# 你也可以试着根据运算符优先级 推算一下结果

res = 5 + 5 <

print(res)

res = (5+5) <

print(res)