关于python:python的运算符

算数运算符

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

品种

+

# 数字类型的加法运算
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)

比拟运算符

概念

1. 比拟两个值是否雷同，后果只会是布尔值，条件成立返回 True，反之 False;
2. 能够比拟任何类型的数据；
3. python 没有向其它语言中一样辨别等于和相对等于的概念，等于就是相对等于，是辨别数据类型的；

品种

print(1234 == '1234')       # False
print(1234 == 1234)         # True

赋值运算符

概念

1. 给某个数据赋予新的值
2. 除了 = 之外的其它赋值运算符，都是在算数运算符的根底上增加了=，应用的办法则和原有的意义基本相同，是将算数进去的后果替换原有的数据
3. 比拟两个值是否雷同，后果只会是布尔值，条件成立返回 True，反之 False;
4. python 没有其它语言的自增和自减概念；

品种

# 间接赋值
var = 'msr'
print(var)      # msr
var = 'hello'
print(var)      # hello

# 通过算数运算得出后果，而后代替原有的数据
var *= 3
print(var)      # hellohellohello

成员运算符

作用

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

品种

字符串

# 只能够间断的元素，就是说不反对含糊查问

var = '你是 Java 的大神，他是 PHP 的开发者，我是 Python 的小白。'
print('Java 的大神' in var)         # True
print('Python 的小白' not in var)   # False

字典

# 在字典当中只会判断键，不会判断值
var = {'及时雨': '宋江', '玉麒麟': '卢俊义'}
print('及时雨' in var)  # True
print('宋江' in var)  # False

身份运算符

作用

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

品种

Python 的内存优化

• 整型：-5 ~~ 正无穷的范畴内的数内存地址雷同
• 浮点型：非正数的内存的地址雷同
• 布尔型：同值内存地址雷同
• 复数：实数 + 虚数的的格局永不雷同
• 容器类型：只有字符串和空元组的状况雷同

intvar = 100
strvar = 'hello'

# 利用 id()函数查看是否是同一地址
res = id(intvar) == id(strvar)
print(res)      # False

# 应用身份运算符
res = intvar is strvar
print(res)      # fasle

逻辑运算符

作用

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

品种

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 => 3

print(15 & 19)

|（按位或）

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

19 的补码：0000 … 10011
15 的补码：0000 … 01111
同位数一个为真的保留下来：0000 … 11111 => 31

print(15 | 19)

^（按位异或）

将数字的补码中，同位数雷同返回假，不同返回真，组合成新数字

19 的补码：0000 … 10011
15 的补码：0000 … 01111
同位数不同的返回真：0000 … 11100 => 28

print(15 ^ 19)

<<（左移位）

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

左移位相当于做乘法，左移 n 位，就相当于乘 2 的 n 次幂

19 的补码：0001 0011
左移 1 位：0010 0110 => 38

print(19 << 1)

>>（右移位）

整个数字向右移位，原位补 0，溢出隐没，组合成新数字
右移位相当于做除法，左移 n 位，就相当于除以 2 的 n 次幂

19 的补码：0001 0011
右移 1 位：0000 1001 => 9

print(19 >> 1)

~ 按位非

按位取反，包含符号位。
公式：-(n + 1)

十进制数：19

原码：0001 0011
反码：0001 0011
补码：0001 0011（先失去一个数的补码）
按位非：1110 1100（按位非，包含符号位在内的全副取反）
补码：1110 1100（后果还是补码）
取反：1001 0011
原码：1001 0100（依据这个补码还原的原码）

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

print(~19)

运算符总结：

运算符品种

1. 算术运算符：+ – / // % *

   1. 比拟运算符：> < >= <= == !=
   2. 赋值运算符：= += -= = /= //= %= *=
   3. 成员运算符：in、not in
   4. 身份运算符：is、is not
   5. 逻辑运算符：and、or、not
   6. 位运算符：& | ^ ~ << >>

运算符优先级

权重从小之下

1. 当多种运算符混合应用：
   算数 > 位 > 比拟 > 身份 > 成员 > 逻辑 > 赋值
2. 一元运算符 > 二元运算符
   一元运算符：同一时间只操作一个值，比方按位非（~19）、逻辑非（not True）
   二元运算符：同一时间操作两个值，少数是这样的，比方幂运算（2 ** 3）、逻辑与（True and False）
3. 算数运算符：
   幂运算 > 乘除 > 加减
4. 位运算符：
   按位非 > 左右移 > 按位与 > 按位异或 > 按位或
5. 逻辑运算符：
   () > not > and > or
6. 赋值运算符：
   = 最小

小教训

这是我的一点心得：

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

在编写简单的运算式的时候要留神尽量的让代码直观，比方能够应用括号。上面的两行运算式的后果一样，然而给人的截然不同。

# 你也能够试着依据运算符优先级 推算一下后果

res = 5 + 5 << 6 // 3 is 40 and True
print(res)

res = (5+5) << (6//3) is 40 and True
print(res)