脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python全栈之运算符详解

Python全栈之运算符详解

2022-03-11 00:13熬夜泡枸杞 Python

这篇文章主要为大家介绍了Python运算符，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助

1. 算数_比较_赋值_成员

1.1 算数运算符

算数运算符: + - * / // % **

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# +
var1 = 7
var2 = 90
res = var1 + var2
print(res)
# -
var1 = 7
var2 = 90
res = var1 - var2
print(res)
# *
var1 = 7
var2 = 10
res = var1 * var2
print(res)
# / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res))
# // 地板除
"""被除数 ➗ 除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
# var2 = 3.0
res = var1 // var2
print(res)
 
# %  取余
var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4  # -3 + 4 = 1
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7   # 4
res = 81 % -7  # -3
res = -81 % 7  # 3
res = -81 % -7 # -4
print(res)
# ** 幂运算
res = 2 ** 3
print(res)

1.2 比较运算符

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

?
1
2
3
4
5
6
7
"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9
print(res)

1.3 赋值运算符

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)
 
var1 = 10
var2 = 5
# +=
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)
# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)
# %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)

1.4 成员运算符

成员运算符: in 和 not in (针对于容器型数据)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"
res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)
# 针对于列表,元组,集合
container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)
# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)

2. 身份运算符

身份运算符 is 和 is not (检测两个数据在内存当中是否是同一个值)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 整型 -5~正无穷
var1 = 100
var2 = 100
print(var1 is var2)
# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2)
# bool 相同即可
var1 = True
var2 = True
print(var1 is var2)
# complex 在实数+虚数不相同 (只有虚数的情况下例外)
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)
# 容器: 相同字符串 , 空元组相同即可  剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)
container1 = "你"
container2 = "你"
print(container1 is not container2)
container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

小提示：

?
1
2
3
4
5
6
# var1和var2地址id是一样的
var1 = 10j
var2 = 10j
# var1和var2地址id是不一样的
var1 = -10j
var2 = -10j

3. 逻辑运算符

逻辑运算符: and or not

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# and 逻辑与  
"""全真则真,一假则假"""
res = True and True    # True
res = True and False   # False
res = False and True   # False
res = False and False  # False
print(res)
# or  逻辑或 
"""一真则真,全假则假"""
res = True or True    # True
res = False or True   # True
res = True or False   # True
res = False or False  # False
print(res)
# not 逻辑非 
res = not True
res = not False
print(res)
# 逻辑短路
"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")
True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False
"""
"""
计算规律:
    先脑补计算当前表达式的布尔值是True还是False
    如果出现了 True or 表达式  或者 False and 表达式的情况,直接返回前者,后面代码不执行
    如果没有出现短路效果,直接返回后者
"""
res = 5 and 6 # 6
"""
True and True =>True
True and False => False
"""
res = 5 or 6  # 5
res = 0 and 999
res = 0 or "abc"
print(res)
# 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or   """
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
"""
not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True
"""
print(res)

3.1 位运算符

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
var1 = 19
var2 = 15
# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)
# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)
# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)
# << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)
"""
000 ... 101  => 5
000 .. 1010  => 10
000 ..10100  => 20
000 .101000  => 40
"""
# >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)
 
# ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011
补码:   000 ... 10011
按位非: 111 ... 01100
给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""
res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101
补码:   111 ... 01101
按位非: 000 ... 10010
给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 18
"""

3.2 小总结

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
总结:
    个别运算符:
        运算符优先级最高的: **
        运算符优先级最低的: =
        ()可以提升优先级
    一元运算符 > 二元运算符 (优先级)
        一元运算符 : 同一时间,操作一个值 ~ -
        二元运算符 : 同一时间,操作一个值 + - * / ....
    同一种类运算符:
        算数运算符 : 乘除 > 加减
        逻辑运算符 : () > not > and > or
        位运算符   : ( << >> ) > & > ^ > |
    整体排序:
        算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
        赋值运算符用来做收尾
"""
res = 5+5 << 6 // 3 is 40 and False
"""
res = 10 << 2 is 40 and False
res = 40 is 40 and False
res = True and False
res = False
"""
print(res)
# 用括号提升下优先级
res = (5+5) << (6//3) is 40 and False

4. 代码块_单项_双项分支

4.1 代码块

代码块：以冒号作为开始,用缩进来划分相同的作用域,这个整体是代码块

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
"""作用域: 作用的范围"""
if 10 == 11:
    print(1)
    print(2)
    print(3)
print(4)
 
# 缩进:要么全都使用\t tab  要么全都是使用4个空格（也可以两个空格，标准的是四个），来表达相同的作用域,不能混再一起;
"""
if 10 == 10:
    print(1)
    print(2)
"""
# 其他语言的写法 (了解)
"""
if(10 == 10){
    print(1)
                    print(2)
                                                                                                print(3)
}
"""

4.2 流程控制

?
1
2
3
4
5
6
7
8
"""
流程: 代码执行的过程
控制: 对代码执行过程中的把控
三大结构:
(1)顺序结构: 默认代码从上到下,依次执行
(2)分支结构: 单项分支 双向分支 多项分支 巢状分支
(3)循环结构: while / for
"""

4.3 单项分支

?
1
2
3
4
5
6
7
8
9
10
11
"""
if 条件表达式:
    code1
    code2
当条件表达式成立,返回True,执行对应的代码块
"""
zhiye = "程序员"
if zhiye == "程序员":
    print("拿高薪")
    print("钱多,话少,死的早")
    print("发量日渐稀少")

4.4 双项分支

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
"""
if 条件表达式:
    code1  ..
else:
    code2 ...
如果条件表达式成立,返回True ,执行if这个区间的代码块
如果条件表达式不成立,返回False,执行else这个区间的代码块
if   分支的代码块也叫做真区间
else 分支的代码块也叫做假区间
"""
 
zhiye = "强盗"
zhiye = "律师"
if zhiye == "强盗":
    print("打他")
    print("骂他")
    print("喂他辣椒水")
else:
    print("给你一朵红花")
 
# input 等待用户输入字符串 (注意:结果一定是字符串)
"""
name = input("你好~ 你妈贵姓~")
print(name , type(name))
"""
# ### 模拟网站登录
# 如果admin = wangwen  密码:password = 111 显示登录成功,否则显示登录失败
# admin = "wangwen"
# password = "111"
admin = input("请输入您的账号:")
password =  input("请输入您的密码:")
if admin == "wangwen" and password == "111":
    print("登录成功")
else:
    print("登录失败")

5. 小作业

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1.99//4  ,  99%4 ,  -99 %4  ,  -99 %-4值是多少
2.成员和身份运算符如何使用
3.逻辑运算符优先级?逻辑短路在什么情况下发生?
4.优先级最高和最低的运算符是?
5.左移右移后的值如何计算?按位非的公式?
6.~(-25) ~25 推到一下过程
7.res = 17>15 or 78<11 or 7 and 8 and not True is True  res=?
8.计算表达式的值
    1).6 or 2 > 1     
    2).3 or 2 > 1     
    3).0 or 5 > 4     
    4).5 < 4 or 3         
    5).2 > 1 or 6     
    6).3 and 2 > 1    
    7).0 and 3 > 1   
    8).2 > 1 and 3   
    9).3 > 1 and 0   
    10).3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2
    11)not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
9.提示用户输入 "如何在dnf中变得更强?". 如果输入的是充钱,打印"马化腾爱你" ,反之输出,"你想一想,不充钱怎么可能变得更强"

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!

原文链接：https://blog.csdn.net/weixin_46818279/article/details/120896992

  • Python
  • 运算符

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图