Python 运算符算数运算符关系运算符赋值运算符逻辑运算 (逻辑运算符的优先级) 位运算成员运算符身份运算符运算符的优先级

1

运算符
- 算数运算符
- 关系运算符
- 赋值运算符
- 逻辑运算
- - 逻辑运算符的优先级
- 位运算
- - 布尔运算符
  - 移位运算符
- 成员运算符
- 身份运算符
- 运算符的优先级

运算符

算数运算符

四则运算+ - * /

a = 8
b = 9
print(a+b)

#与Java类似 + 也可以进行字符串的连接 注意:字符串+数字=字符串  不存在会抛出异常这里与java不同
print(a-b)
print(a*b)
print(a/b)

取模运算 %

a=10
b=3
print(10 % 3) #---->1
    #在python中取模结果的符号与出书相同
print(-10 % 3) #---> 2

之所以出现1 与 2 的不同是因为python取模计算规则为 r = p-q*floor(p/q) floor表示向下取余

**幂 ****

print(4**2) #-->16  表示4的二次方

取整除向下取整 ‘//’

print(10//6)# -->1

关系运算符

等于关系 ==

print(2==2) #-->True 结果为bool型

大于大于等于(大于||等于)

print(2>3)#-->False
print(2>=2)#-->True

小于小于等于(小于||等于)

print(2<3)#-->True
print(2<=2)#-->True

!= 不等于

print(2!=2) #-->False
print(2!=3) #-->True

不同数据类型之间的比较,若是不同的数据类型进行比较 python会先尝试进行类型转换,然后在进行比较

数字与数字之间的比较
- 如果都为整型或者 浮点型 则直接比较
- 如果一个是整型一个是浮点型 则整数转换为浮点数后在进行比较
- 如果一个对象是复数,则不支持比较会抛出异常
- ```
c =  1+2j #-->虚数
d = 1
print(c<d)#-->抛出异常 TypeError  '<=''>='依然抛出异常
```
字符串与字符串进行比较
- 如果**两个字符串不为空,**则按照字母顺序表序进行比较
- 如果一个字符串为空,则认为它比非空字符串要小
- 如果两个字符串都为空 ,则认为它俩相等
- ```
str1 = "aaa"
str2 = "aaa"
print(str1 == str2) #-->True

str3 = ""
str4 = "1"
print(str3<str4)# -->True
```
列表,元组之间的比较
- 如果两个列表(元组)长度相等,则按照元素顺序依次进行比较
- 如果两个列表(元组)长度不相等,则先比较相同位置上的元素,如果都相等则长度更长的列表(元组)更大,否则比较第一个不同元素的大小
- 如果列表(元组)中包含不同类型的元素,则会尝试对他们进行类型转换,然后在进行比较
- ```
# 列表与列表进行比较
list1 = [1 ,2 ,3]
list2 = [1,2,3,4]
print(list1 == list2)# False
# 元组与元组之间的比较
tu1 = (1 ,2 ,3)
tu2 = (1,2,3)
print(tu1==tu2)# True
#列表与元组比较
print(list1!=tu1)# True  
#print(list2<=tu2) #-->报错
```
  注:除了数字之间字符串之间 ==与!= 是用来判断类型相等或者不相等
字符串与数字比较
- 在python中,字符串与数字是不同类型的对象,不能直接比较大小,会抛出一个异常,如果是 ==或!= 则不会因为是用来判断类型是否一致
- ```
print("123"==123)# -->false
# print("123"<123) -->抛出类型不一致异
```

赋值运算符

简单的赋值运算 表示将右边的值复制给左边的值
- ```
a = 10
b = 10.1
c = "hello world"
```

算术赋值运算符 += -= *= /=

a+=10
b-=10
c+="1" #字符串与字符串之间使用'+'表示字符串的连接
print(a)#-->20
print(b)#-->0.09999999999999964  
    # 之所以不是0.1 是因为与电脑存储浮点数据方式有关
print(c)#-->hello world1
a=10
b=2
a*=10
b/=2
print(a) #-->100
print(b) #-->1.0

取模赋值运算符
- ```
a = 10
a %=3
print(a)#-->1
```
幂赋值运算符
- ```
a = 4
a **=2
print(a)#-->16
```
取整除赋值运算符
- ```
a=15
a//=4
print(a)#-->3
```

逻辑运算

and 与运算
- x and y 表示如果x为假则x and y返回x的值否则(非False)返回y的计算值
- ```
a=1
b=2
print(a and b)#-->2
a=False
print(a and b)#-->False
```
- 注:python的与运算与java是有区别的 java中的&&运算结果是bool类型非真即假,但是python结果是任何类型

or 或运算

x or y 表示如果x 是True,他返回x的值,否则返回y的计算值

x=5
y=10
print(x or y)# -->5
print(x==4 or y)# -->10
# 注意 当x为True时 则不会判断后面的y

not(非)运算
not x 表示如果x为True 则结果为False …理解为去反
```
a = False
print(not a)# -->True
```

逻辑运算符的优先级

先举个例子

# 代码1
a=True
b=False
if not b or a:
    print("not 操作优先级大于 or 操作")# -->not 操作优先级大于 or 操作

#....类似进行比较  总结如下
#

结论 :not > and >or

位运算

布尔运算符

按位与运算 ‘&’
- 果两个数据对应的二进制位都为1 则为1 否则为0
- ```
a = 9  #1001
b = 10 #1010
print(a & b) #--> 8   1000
```
按位或运算 ‘|’
- 如果数据对应的二进制位有一个1时则为1 全0则0
- ```
a = 9  #1001
b = 10 #1010
print(a|b)#-->11 1101
```
按位异或运算 ‘^’
- 定义:当两个对应二进制位相异时结果为 1
- ```
a = 9        #1010
b = 10       #1010
print(a^b)#3  0011
```
按位取反运算 ‘~’
- 定义:对数据的每个二进制位去反(1–>0,0–>1)
```
a = 9        #0000 1001
print(~a)#-10 
```
- 注意:正数的补码是它本身,负数的补码为正数值二进制位取反后+1,符号位为1
- 0000 1001
  
  # 补码 0000 1001
  
  # 取反 1111 0110 -->负数所以进行补码处理
  
  #新补码 1000 1010 -->-10

移位运算符

左移位运算符(<<)
- 定义:运算数的各个二进制全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0
- ```
a=9 # 0000 1001
print(a<<2) #36 0010 0100
```
右移运算符(>>)
- 定义:把">>“的运算数的各二进制全部右移若干位,”>>"右边数指定移动的位数,低位丢弃,高位补零
- ```
a = 9 # 0000 1001
print(a>>2) #2 0000 0010  
print("成员运算符")
```

成员运算符

成员运算符用于识别某一元素是否包含在变量中,这个变量可以是字符串,列表,元组,因为是判断在或者不在,所以有两个运算符in 和not in得到的结果为bool类型

in

判断变量是否包含某元素,包含返回true,不包含返回False

a=1
b=10
list = [1,2,3,4,5,6]
if(a in list):
    print("a在list中")
else:
    print("a不在list中")
# a在list中

if(b in list):
    print("b在list中")
else:
    print("b不在list中")
# b不在list中
    
#当然in 运算符也可以进行字符串的匹配
s = "cuiweiyang"
str1 = "cui"
str2 = "zhang"
if(str1 in s):
    print("str1在s中")
else:
    print("str1不在s中")
# str1在字符串2中
    
if(str2 in s):
    print("str2在s中")
else:
    print("str2不在s中")
# str2不在字符串s中
# not in 刚好与in相反 用法是一致的
print("身份运算符")

not in 刚好与in相反用法是一致的

身份运算符

is 是判断两个标识符是不是引用自一个对象,比如 x is y,类似于 id(x)==id(y),如果是引用同一个对象,返回True(bool类型),否则返回False(注:id()函数是用于获取对象的内存地址)

is not 刚好与is 相反

a = 20
b = 20
if(a is b):
    print("a与b有相同的标识")
else:
    print("a与b没有相同的标识")
    #a与b有相同的标识
b=30
if(a is b):
    print("a与b有相同的标识")
else:
    print("a与b没有相同的标识")
    #a与b没有相同的标识

is与== 的区别

is是用来判断两个变量引用对象是否为同一个也就是比较引用对象的地址,==用于判断引用变量的值是否相等

 #eg:
    a=[1,2,3]
    b=a
    print(a is b)#True
    print(a == b)#True
    b=a[:]
    print(a is b)#Fasle
    print(a == b)#True  b=a[:]会创建一个新的与a完全相同的对象,但是与a并不指向同一个对象

运算符的优先级

圆括号表达式
- ```
print((1+2)*3)# -->9
```
取,切片,调用,属性引用 [],[:],(), .
- 分别为 x[index],x[index:index],x(arguments...),x.attribute
  
  # x(arfuments...):函数调用运算符()**优先级最高,**总是首先执行,在一个表达式中,由于小括号可以改变运算符优先级关系,因此这个运算符是最强的
  
  # x[index] x[index:index]:它们优先级相同,都比点运算符低,这两个运算符都是序列类型(如字符串,列表和元组)中的索引和切片操作符,用于获取序列中的元素伙子序列
  
  # x.attribute:点运算符,是访问对象属性的运算符,在运算符优先级中优先级最低,在一个表达式中,点运算符总是最后执行,并且可以链接多个点运算符形成一个长链 eg:obj.atrr1,atrr2
- ```
my_list = ["apple","banana","cherry"]
index = 1
result = my_list[index].upper()
print(result)
# 这里定义了一个列表my_list 和一个整数变量index ,接着,我们使用索引操作my_list[index]访问了列表的第二个元素"banana",得到一个字符串对象,在使用.点运算符调用
    #将其字母全部大写,然后打印结果
```
await表达式
- await 是用来等待线程完成的,像await x则是表达一个暂停当前线程的语法
乘方(指数)**
正,负,按位非,not
乘,矩阵乘,除,整除,取余
加和减
移位
按位与 &
按位异或 ^
按位或 |
比较运算符(包括成员检测和标识号检测符)
逻辑非 not
逻辑与 an
逻辑或 or
条件表达式(三元表达式)
- ```
print(5 if 5>2 else 2) #-->5  
```
- a = 表达式1 if 条件 else 表达式 2 如果条件成立表达式1赋值给a,负责表达式2赋值给a
lambda表达式
- lambda表达式是一种创建匿名函数的语法结构,一下是一个使用lambda表达式实现简单的加法运算实例代码
```
add = lambda x,y:x+y

print(add(3,5))#-->8
```
赋值表达式(也称为海象运算符)