python3大于等于_Python3运算符

Python3 运算符

什么是运算符？

Python语言支持以下类型的运算符:

算术运算符

比较（关系）运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

运算符优先级

Python算术运算符

以下假设变量a为10，变量b为21：

运算符描述实例

+

加 - 两个对象相加

a + b 输出结果 31

-

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -11

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 210

/

除 - x 除以 y

b / a 输出结果 2.1

%

取模 - 返回除法的余数

b % a 输出结果 1

**

幂 - 返回x的y次幂

a**b 为10的21次方

//

取整除 - 向下取接近除数的整数

>>>9//24>>>-9//2-5

以下实例演示了Python所有算术运算符的操作：

实例(Python 3.0+)

#算术运算符#+ 加法运算符（如果是两个字符串之间进行加法运算，则会进行拼串操作）#- 减法运算符#* 乘法运算符（如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数）#/ 除法运算符，运算时结果总会返回一个浮点类型#// 整除，只会保留计算后的整数位，总会返回一个整型#** 幂运算，求一个值的几次幂#% 取模，求两个数相除的余数

a= 10 + 5 #计算

a = 'hello' + ' ' + 'world' #拼串

a= 10 - 5 #计算

a = 5 -True

a= a - 2 #用变量a的值减去2，然后再赋值给a

print('a=',a)#a = 'hello' - 'h' TypeError

a= 5 * 5

print('a=',a)

a= 10 / 5a= 5 / 2

print('a=',a)#a = 5 / 0 ZeroDivisionError: division by zero

a = 10 / 3

print('a=',a) #a= 3.3333333333333335

a = 10 // 3

print('a=',a) #a= 3

a = 5 // 2

print('a=',a) #a= 2

a = 2 ** 2

print('a=',a) #a= 4

a = 10 ** 5

print('a=',a) #a= 100000

a = 16 ** 0.5 #求16的平方根

print('a=',a)

a= 10 % 5 #0

a = 10 % 4 #2

a = 10 % 3 #1

a = 10 % 2 #0

print("a =",a)

以上实例输出结果：

E:\PyWorkSpace\venv\Scripts\python.exe E:/PyWorkSpace/venv/aaa.py

a= 2a= 25a= 2.5a= 3.3333333333333335a= 3a= 2a= 4a= 100000a= 4.0a=0

Process finished with exit code 0

Python比较运算符

以下假设变量a为10，变量b为20：

运算符描述实例

==

等于 - 比较对象是否相等

(a == b) 返回 False。

!=

不等于 - 比较两个对象是否不相等

(a != b) 返回 True。

>

大于 - 返回x是否大于y

(a > b) 返回 False。

<

小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。

(a < b) 返回 True。

>=

大于等于 - 返回x是否大于等于y。

(a >= b) 返回 False。

<=

小于等于 - 返回x是否小于等于y。

(a <= b) 返回 True。

以下实例演示了Python所有比较运算符的操作：

实例(Python 3.0+)

#关系运算符#关系运算符用来比较两个值之间的关系，总会返回一个布尔值#如果关系成立，返回True，否则返回False#> 比较左侧值是否大于右侧值#>= 比较左侧的值是否大于或等于右侧的值#< 比较左侧值是否小于右侧值#<= 比较左侧的值是否小于或等于右侧的值#== 比较两个对象的值是否相等#!= 比较两个对象的值是否不相等#相等和不等比较的是对象的值，而不是id#is 比较两个对象是否是同一个对象，比较的是对象的id#is not 比较两个对象是否不是同一个对象，比较的是对象的id

result = 10 > 20 #False

result = 30 > 20 #True

result = 30 < 20 #False

result = 10 >= 10 #True

result= 2 > True #True#result = 2 > '1' TypeError: '>' not supported between instances of 'int' and 'str'

#0032 > 0031

result = '2' > '1' #True

result = '2' > '11' #True

#在Python中可以对两个字符串进行大于（等于）或小于（等于）的运算，#当对字符串进行比较时，实际上比较的是字符串的Unicode编码#比较两个字符串的Unicode编码时，是逐位比较的#利用该特性可以对字符串按照字母顺序进行排序，但是对于中文来说意义不是特别大#注意：如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字然后再比较#0061 > 0062

result = 'a' > 'b' #False

result = 'c' < 'd' #True

result = 'ab' > 'b' #False

#print(int('2') > int('11'))

result= 1 == 1 #True

result = 'hello' == 'hello' #True

result = 'abc' == 'bcd' #False

result = 'abc' != 'bcd' #True

result = 1 == True #True

result = 1 is True #False

result = 1 is not True #True

print('result =',result)print(id(1),id(True))

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符描述实例

=

简单的赋值运算符

c = a + b 将 a + b 的运算结果赋值为 c

+=

加法赋值运算符

c += a 等效于 c = c + a

-=

减法赋值运算符

c -= a 等效于 c = c - a

*=

乘法赋值运算符

c *= a 等效于 c = c * a

/=

除法赋值运算符

c /= a 等效于 c = c / a

%=

取模赋值运算符

c %= a 等效于 c = c % a

**=

幂赋值运算符

c **= a 等效于 c = c ** a

//=

取整除赋值运算符

c //= a 等效于 c = c // a

:=

海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

在这个示例中，赋值表达式可以避免调用 len() 两次:

if(n :=len(a))>10:print(f"List is too long ({n} elements, expected <= 10)")

以下实例演示了Python所有赋值运算符的操作：

实例(Python 3.0+)

#赋值运算符#= 可以将等号右侧的值赋值给等号左侧的变量#+= a += 5 相当于 a = a + 5#-= a -= 5 相当于 a = a - 5#*= a *= 5 相当于 a = a * 5#**= a **= 5 相当于 a = a ** 5#/= a /= 5 相当于 a = a / 5#//= a //= 5 相当于 a = a // 5#%= a %= 5 相当于 a = a % 5

a = 10a= a + 5

print('a =',a)

a+= 5

print('a =',a)

a-= 5

print('a =',a)

a*= 5

print('a =',a)

a**= 2

print('a =',a)

a/= 25

print('a =',a)

a= 25.0 #在对浮点数做算术运算时，结果也会返回一个浮点数

a //= 5

print('a =',a)

a= 5

print('a =',a)

a%= 4

print('a =',a)

以上实例输出结果：

E:\PyWorkSpace\venv\Scripts\python.exe E:/PyWorkSpace/venv/bbb.py

a= 15a= 20a= 15a= 75a= 5625a= 225.0a= 5.0a= 5a= 1Process finished with exit code 0

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100b= 0000 1101

-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001

~a = 1100 0011

运算符描述实例

&

按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

(a & b) 输出结果 12 ，二进制解释： 0000 1100

|

按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

(a | b) 输出结果 61 ，二进制解释： 0011 1101

^

按位异或运算符：当两对应的二进位相异时，结果为1

(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~

按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1

(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

<<

左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

a << 2 输出结果 240 ，二进制解释： 1111 0000

>>

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了Python所有位运算符的操作：

实例(Python 3.0+)

a = 60 #60 = 0011 1100

b = 13 #13 = 0000 1101

c =0

c= a & b; #12 = 0000 1100

print ("1 - c 的值为：", c)

c= a | b; #61 = 0011 1101

print ("2 - c 的值为：", c)

c= a ^ b; #49 = 0011 0001

print ("3 - c 的值为：", c)

c= ~a; #-61 = 1100 0011

print ("4 - c 的值为：", c)

c= a << 2; #240 = 1111 0000

print ("5 - c 的值为：", c)

c= a >> 2; #15 = 0000 1111

print ("6 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 12

2 - c 的值为： 61

3 - c 的值为： 49

4 - c 的值为： -61

5 - c 的值为： 240

6 - c 的值为： 15

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符逻辑表达式描述实例

and

x and y

布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

(a and b) 返回 20。

or

x or y

布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

(a or b) 返回 10。

not

not x

布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

not(a and b) 返回 False

以上实例输出结果：

实例(Python 3.0+)

#逻辑运算符#逻辑运算符主要用来做一些逻辑判断#not 逻辑非#not可以对符号右侧的值进行非运算#对于布尔值，非运算会对其进行取反操作，True变False，False变True#对于非布尔值，非运算会先将其转换为布尔值，然后再取反# #and 逻辑与#and可以对符号两侧的值进行与运算#只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False#与运算是找False的#Python中的与运算是短路的与，如果第一个值为False，则不再看第二个值# #or 逻辑或#or 可以对符号两侧的值进行或运算#或运算两个值中只要有一个True，就会返回True#或运算是找True的#Python中的或运算是短路的或，如果第一个值为True，则不再看第二个值# #练习：#尝试一下对布尔值进行三种逻辑运算#尝试对非布尔值进行三种逻辑运算，并观察返回的结果#

a=True

a= not a #对a进行非运算

a= 1a= ''a= nota#print('a =',a)

result= True and True #True

result = True and False #False

result = False and True #False

result = False and False #False

#print(result)

#True and print('你猜我出来吗？') 第一个值是True，会看第二个值，所以print()会执行#False and print('你猜我出来吗？')第一个值是False，不会看第二个值，所以print()不会执行

result= True or True #True

result = True or False #True

result = False or True #True

result = False or False #False

#print(result)#False or print('你猜我出来吗？') 第一个值为False，继续看第二个，所以打印语句执行#True or print('你猜我出来吗？') 第一个值为True，不看第二个，所以打印语句不执行

#非布尔值的与或运算#当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值#与运算的规则#与运算是找False的，如果第一个值是False，则不看第二个值#如果第一个值是False，则直接返回第一个值，否则返回第二个值#或运算的规则#或运算是找True的，如果第一个值是True，则不看第二个值#如果第一个值是True，则直接返回第一个值，否则返回第二个值

#True and True

result = 1 and 2 #2#True and False

result = 1 and 0 #0#False and True

result = 0 and 1 #0#False and False

result = 0 and None #0

#True or True

result = 1 or 2 #1#True or False

result = 1 or 0 #1#False or True

result = 0 or 1 #1#False or False

result = 0 or None #None

print(result)

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符描述实例

in

如果在指定的序列中找到值返回 True，否则返回 False。

x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in

如果在指定的序列中没有找到值返回 True，否则返回 False。

x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下实例演示了Python所有成员运算符的操作：

实例(Python 3.0+)

a = 10b= 20list= [1, 2, 3, 4, 5];if ( a inlist ):print ("1 - 变量 a 在给定的列表中 list 中")else:print ("1 - 变量 a 不在给定的列表中 list 中")if ( b not inlist ):print ("2 - 变量 b 不在给定的列表中 list 中")else:print ("2 - 变量 b 在给定的列表中 list 中")#修改变量 a 的值

a = 2

if ( a inlist ):print ("3 - 变量 a 在给定的列表中 list 中")else:print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 -变量 a 不在给定的列表中 list 中2 -变量 b 不在给定的列表中 list 中3 - 变量 a 在给定的列表中 list 中

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符描述实例

is

is 是判断两个标识符是不是引用自一个对象

x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not

is not 是判断两个标识符是不是引用自不同对象

x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

实例(Python 3.0+)

a = 20b= 20

if ( a isb ):print ("1 - a 和 b 有相同的标识")else:print ("1 - a 和 b 没有相同的标识")if ( id(a) ==id(b) ):print ("2 - a 和 b 有相同的标识")else:print ("2 - a 和 b 没有相同的标识")#修改变量 b 的值

b = 30

if ( a isb ):print ("3 - a 和 b 有相同的标识")else:print ("3 - a 和 b 没有相同的标识")if ( a is notb ):print ("4 - a 和 b 没有相同的标识")else:print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 -a 和 b 有相同的标识2 -a 和 b 有相同的标识3 -a 和 b 没有相同的标识4 - a 和 b 没有相同的标识

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符描述

**

指数 (最高优先级)

~ + -

按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //

乘，除，求余数和取整除

+ -

加法减法

>> <<

右移，左移运算符

&

位 'AND'

^ |

位运算符

<= < > >=

比较运算符

== !=

等于运算符

= %= /= //= -= += *= **=

赋值运算符

is is not

身份运算符

in not in

成员运算符

not and or

逻辑运算符

以下实例演示了Python所有运算符优先级的操作：

实例(Python 3.0+)

a = 40b= 50c= 30

#通过条件运算符获取三个值中的最大值#max = a if a > b else b#max = max if max > c else c

max= a if (a > b and a > c) else (b if b > c else c) #不推荐这么使用#max = a if (b < a > c) else (b if b > c else c)

#print(max)

#运算符的优先级#和数学中一样，在Python运算也有优先级，比如先乘除 后加减#运算符的优先级可以根据优先级的表格来查询，#在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算#如果优先级一样则自左向右计算#关于优先级的表格，你知道有这么一个东西就够了，千万不要去记#在开发中如果遇到优先级不清楚的,则可以通过小括号来改变运算顺序

a = 1 + 2 * 3

#一样 and高 or高#如果or的优先级高，或者两个运算符的优先级一样高#则需要先进行或运算，则运算结果是3#如果and的优先级高，则应该先计算与运算#则运算结果是1

a = 1 or 2 and 3

print(a)#逻辑运算符（补充）#逻辑运算符可以连着使用

result = 1 < 2 < 3 #相当于 1 < 2 and 2 < 3

result = 10 < 20 > 15

print(result)

Python条件运算符

#条件运算符（三元运算符）#语法： 语句1 if 条件表达式 else 语句2#执行流程：#条件运算符在执行时，会先对条件表达式进行求值判断#如果判断结果为True，则执行语句1，并返回执行结果#如果判断结果为False，则执行语句2，并返回执行结果#练习：#现在有a b c三个变量，三个变量中分别保存有三个数值，#请通过条件运算符获取三个值中的最大值

print('你好') if False else print('Hello')

a= 30b= 50

#print('a的值比较大！') if a > b else print('b的值比较大！')#获取a和b之间的较大值

max = a if a > b elsebprint(max)

结果：

E:\PyWorkSpace\venv\Scripts\python.exe E:/PyWorkSpace/venv/bbb.py

Hello50Process finished with exit code 0