【Python学习第八篇】表达式 -- 运算符
👨🎓博主简介
🏅云计算领域优质创作者
🏅华为云开发者社区专家博主
🏅阿里云开发者社区专家博主
💊交流社区：运维交流社区 欢迎大家的加入！
🐋 希望大家多多支持，我们一起进步！😄
🎉如果文章对你有帮助的话，欢迎 点赞 👍🏻 评论 💬 收藏 ⭐️ 加关注+💗
1、前言
这里写代码的工具为：PyCharm 2022.3.3
Python 版本为：3.8.5
工作平台：Windows
2、表达式概述
2.1 认识表达式
表达式就是计算的式子，有计算符和操作数组成。表达式必须返回一个值。操作数是参与运算的对象，包括字面值、变量、对象、表达式等。
Python的表达式是一组代码，它们可以被解释器解析为一个值、对象或操作。表达式可以包括变量、函数调用、运算符、常量等，例如：
# 交互式界面
"python" # 字符串表达式，输出结果为 python
2 + 3 * 4 # 运算表达式，结果为 14
"Hello, " + "world!" # 字符串拼接表达式，结果为 "Hello, world!"
x = 42 # 赋值表达式，将值 42 赋给变量 x
len("hello") # 函数调用表达式，结果为 5
#解析器
print(str("python")) # 字符串表达式，输出结果为 python
print(2+3*4) # 运算表达式，结果为 14
print("Hello, " + "world!") # 字符串拼接表达式，结果为 "Hello, world!"
x = 42
print(int(x)) # 赋值表达式，将值 42 赋给变量 x
print(len("hello")) # 函数调用表达式，结果为 52.2 定义表达式
简单的表达式： 一个值 一个变量
复杂的表达式： 由简单的表达式组成复杂的表达式嵌套可以组成更复杂表达式
表达式运算： 从内到外，依次逐级上移
表达式运算顺序： 从左到右可以使用小括号改变表达式的运算顺序
举个例子：
(3-2-1)*(3+2+1)*(3*2*1) # 结果= 0
print((3-2-1)*(3+2+1)*(3*2*1)) # 结果= 0分组
(a+b>c and a-b<c or a>b>c) # 这样看着比较乱，不好看出什么意思，这个就是未分组
((a+b>c) and ((a-b<c) or (a>b>c))) # 分组了，这样看着就比较清晰了2.3 认识运算符
运算符表示特点给算法的符号，大部分由标点符号表示（+、-、=等等），少数运算符由单词组成（or、and、in、is、for）。运算符必须与操作数配合使用，组成表达式，才能发挥作用。根据操作数的数量，运算符可分为3中类型：
- 一元运算符：有1个操作数，如：取反、逻辑非not、一元减号一。
- 二元运算符：有2个操作符，也是最常用的，需要两个操作符结合使用。
- 三元运算符：有3个操作符，一般用于条件表达式中。
Python中的运算符有以下几种：
1. 括号和小数点（最高优先级）
2. 幂运算符：**
3. 正负号：+x, -x
4. 乘除模运算符：*，/，%
5. 加减运算符：+，-
6. 位运算符：
- 按位取反：~
- 位与：&
- 位或：|
- 异或：^
- 左移、右移运算符：<<, >>
7. 比较运算符：==，!=，>，<，>=，<=
8. 逻辑运算符：
- 与：and
- 或：or
- 非：not
9. 赋值运算符：=，+=，-=，*=，/=，%=，**=，//=
10. 身份运算符：
- is
- is not
11. 成员运算符：
- in
- not in
12. 最低优先级：逗号（,）从高到低排序：
1. 括号和小数点（最高优先级）
2. 幂运算符：**
3. 正负号：+x, -x
4. 乘除模运算符：*，/，%
5. 加减运算符：+，-
6. 位运算符： ~, &, |, ^, <<, >>
7. 比较运算符：==，!=，>，<，>=，<=
8. 逻辑运算符：not，and，or
9. 赋值运算符：=，+=，-=，*=，/=，%=，**=，//=
10. 身份运算符：is，is not
11. 成员运算符：in，not in
12. 最低优先级：逗号（,）例如：（常用的数学上的运算）
# + 与 * 的数字计算
4+4*5
先算4*5，因为*号的优先级比+号高，所以先算乘号；
再算4+(4*5) = 4+20 = 24，所以结果是24。
# / 与 * 的数字计算
100/25*6
这里/和*是相等的优先级，所以从左到右以此计算：(100/25)*6 = 4*6 = 242.4 条件表达式
条件表达式就是属于判断表达式；
条件语句无法参与表达式运算，如果在表达式中应用条件检测，可以选择条件表达式。
条件表达式是python唯一的三元运算符，语法格式如下：
<True表达式> if <条件表达式> else <False表达式>如果条件表达式为True，则执行True表达式，否则执行False表达式。
【示例1】将变量n的绝对值赋值给变量x
n = int(input("请输入一个数字："))
x = n if n>=0 else -n
print(x)解析：
其中x = n if n >= 0 else -n 表达式等效于下面的条件语句：
if n>=0:
x = n
else:
x = -n提示：可以使用列表结构来模拟条件表达式，语法格式如下：
[False 表达式,Tre 表达式条件表达式]
针对示例1中的x = n if n >=0 else -n一行代码，使用二维列表来表示，代码如下。
x=[-n,n][n>=0]
如果n>=0成立，返回True,转换为数宇1，则从列表中读取第二个元素;如果n>=0不成立，返回 False,转换为数宇0，则从列表中读取第一个元素。
【示例2】提示输入用户名和密码，如果用户名和密码都输入正确，则提示 “欢迎登录！”，如果用户名或密码输入错误，则提示 “用户名或密码输入错误！”，假定用户名为 test，密码为 123456。
username = input("请输入用户名：")
userpaswd = input("请输入密码：")
result = "欢迎登陆！"if username == "test" and userpaswd == "123456" else "用户名或密码输入错误！"
print(result)可视化解析:
#首先用户可以输入用户名和密码
username = input("请输入用户名：")
userpaswd = input("请输入密码：")
#if判断，如果username=="test"并且userpasswd=="123456"的话就输出“欢迎登录！”；否则输出“用户名或密码输入错误！”并输出。
if username == "test" and userpaswd == "123456":
result = "欢迎登陆！"
else:
result = "用户名或密码输入错误！"
print(result)3、算术运算
算数运算包括：加（+）、减（-）、乘（*）、除（/）、求余（%）、求整（//）、求幂（**）
- 图解：
- 【示例1】随机抽取4个1~10之间的数字，编写表达式，使用算术运算让它们总是等于24。注意，每个数字必须使用，且只能使用一次。示例代码如下:
print(((1+4)*4)+4) # 1+4=5 5*4=20 20+4=24
print(4*((5*3)-9)) # 5*3=15 15-9=6 4*6=24
print((2 * (3 + 10)-2)) # 3+10=13 2*13=26 26-2=24
print(((5 * 6)+ 1)-7) # 5*6=30 30+1=31 31-7=24- 【示例 2】设计一个表达式，求一个数字连续运算2 次，运算结果总等于 6，如 2+2+2=6。如果这个数字为(1)~(9)时，请编写表达式，确保每个表达式的值都为6。
(1)当数字为2时，则表达式为:2+2+2。
print(2+2+2)(2)当数字为3时，则表达式为:3*3-3。
print(3*3-3)(3)当数字为5时，则表达式为: 5/5+5。
print(5/5+5)(4)当数字为6时，则表达式为:6-6+6。
print(6-6+6)(5)当数字为7时，则表达式为:7-7/7。
print(7-7/7)(6)当数字为4时，则表达式为: 根号4+根号4+根号4
print(4**0.5+4**0.5+4**0.5)(7)当数字为8时，则表达式为: 3根号8+3根号8+3根号8
print(8**(1/3)+8**(1/3)+8**(1/3))
print(pow(8,1/3)+pow(8,1/3)+pow(8,1/3))（8）当数字为9时，则表达式为：根号9*根号9-根号9
print(9**(1/2)*9**(1/2)-9**(1/2))
print(pow(9,1/2)*pow(9,1/2)-pow(9,1/2))（9） 当数字为1时，可以使用阶乘，则表达式为：(1+1+1)!，3!=321
import math #导入数学运算模块
print(math.factorial(1+1+1)) #调用阶乘函数或者使用递归两数定义一个求阶乘函数，代码如下：
def factorial(n): # 阶乘函数
if n == 0: # 设置终止递归的条件
return 1
else:
return n * factorial( n - 1 ) # 递归求积
print(factorial(1+1+1))- 【示例 3】计算 100 以内所有偶数和。
sum = 0 # 临时汇总变量
for i in range(101): # 迭代100以内的所有数字
if i % 2 == 0: # 如果与2相除=0，则为偶数
sum = sum + i # 叠加偶数和
print(sum) # 输出为：25504、赋值运算
- 图解：
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 直接赋值 | c = 10 # 变量c的值为10 |
| += | 先相加，后赋值 | 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 |
- 【示例1】要求用户输入字符，然后计算有多少个数字和字母
content=input("请输入字符：") # 交互式输入，输入要写的内容
num = 0 # 定义变量num，统计数字的个数
str = 0 # 定义变量str，统计字符的个数
for n in content: # 循环遍历字符串
if n.isdecimal()==True: # 如果是数字，isdecimal：用于检查字符串是否只包含十进制数字
num+=1 # 那么就加累计加数字个数
elif n.isalpha()==True: # 如果是字符，isalpha：用于检查字符串是否只包含字母
str+=1 # 那么就累计加字符个数
else: # 否则
pass # 空语句，不做任何事情（主打的是一个占位）
print("数字个数：",num) # 输出数字的个数
print("字符个数：",str) # 输出字符的个数
5、关系运算
5.1 大小关系
大小关系包含四个运算符，用于比较两个相同类型的操作数。所有比较运算符返回1表示True，返回0表示False。
操作数可以是字符串或数字，如果是数字，则直接比较大小，如果是字符串，则根据每个字符编码的大小，从左到右按顺序逐个比较。字符比较区分大小写，一般小写字符大于大写字符，如果不区分大小写，可以使用upper()或lower()方法统一字符串的大小写形式，如果操作时是布尔值，则先转化为数字，True为1，False为0，再进行比较。
- 图解：
| 运算符 | 描述 | 示例 |
|---|---|---|
| > | 大于 | (10>20) # 返回False |
| < | 小于 | (10<20) # 返回True |
| >= | 大于等于 | (10>=20) # 返回False |
| <= | 小于等于 | (10<=20) # 返回True |
- 【示例1】要求输入字符串，将小写字符转换为大写字符，将大写字符转换为小写字符。
str = input("请输入字符：") # 接收一个字符串
str1="" # 定义一个空字符串,用于存储转换后的结果
for cha in str: # 循环遍历字符串
if "a" <= cha <= "z": # 判断字符是否是小写,如果是
cha1 = ord(cha)-32 # 那么就将字符转为ASCII值,该值减去32变为大写
elif "A" <= cha <= "Z": # 判断字符是否是大写,如果是
cha1 = ord(cha)+32 # 那么就转换为小写字符对应的ASCII值
str1 += chr(cha1) # 将ASCII值转为字符型
print(str1) # 打印转换后的结果
def swap_case(s): # 定义一个函数swap_case(s),这个函数接受一个字符串s作为输入.
return s.swapcase() # 然后调用python的swapcase方法,将大写转换为小写,小写转换为大写; swapcase:用于将字符串中的所有大写字母转换为小写，并将所有小写字母转换为大写。
input_str = input("请输入一个字符串：") # 定义一个变量,让用户输入字符串;
print(swap_case(input_str)) # 最后，我们调用我们定义的swap_case()函数，并将用户输入的字符串作为参数传递给它。然后，我们打印出swap_case()函数返回的字符串，这就是转换了大小写的字符串。
- 【示例2】要求用户输入3个字符串，并比较3个字符串的大小。2个字符串进行大小比较时，时按照从左到右的顺序，依次比较相应位置的字符的ASCII码值的大小。
str1 = input("请输入第一个字符串：") # 接收输入的字符串
str2 = input("请输入第二个字符串：")
str3 = input("请输入第三个字符串：")
print('前面输入的三个字符串（从左到右）：',str1,str2,str3) # 打印排序前的字符串顺序
if str1 > str2: # 判断两个字符的大小
str1,str2 = str2,str1 # 交换两个字符串（后面会学到）下面都是一样的
if str1 > str3:
str1,str3 = str3,str1
if str2 > str3:
str2,str3 = str3,str1
print("排序后的字符串：",str1,str2,str3) # 打印排序后的字符串顺序
5.2 相等关系
相等关系包含两个运算符
- 图解：
| 运算符 | 描述 | 示例 |
|---|---|---|
| == | 比较两个对象是否相等 | 1 == 1 # 返回True |
| != | 比较两个对象是否不相等 | 1 != 1 # 返回False |
相等关系的两个操作数没有类型限制。如果类型不同，则不相等，直接返回 False：如果类型相同，比较值是否相同，如果相同，则返回 True，否则返回 False。如果操作数是布尔值，则先转换为数字，为1，False 为0，再进行比较。
- 【示例】假设有一筐鸡蛋，准备取出，如果：1个1个拿，正好拿完；2个2个拿，还剩1个；3个拿，正好拿完；4个4个拿，还剩1个；5个5个拿，还剩1个；6个6个拿，还剩3个；7个7个 正好拿完；8个8个拿，还剩1个；9个9个拿，正好拿完。问框里最少有多少个鸡蛋。
for i in range(1,1000): # 假设现在有最多1000个鸡蛋，循环去取i
# 判断，一个一个拿，刚好拿完，那么就是i %(余) 1 = 0；后面以此类推；and在这里是并且（与）的意思，意思就是要满足这些所有条件，才可以输出值；
if i % 1 == 0 and i % 2 == 1 and i % 3 == 0 and i % 4 == 1 and i % 5 == 1 and i % 6 == 3 and i % 7 == 0 and i % 8 == 1 and i % 9 == 0:
print(i) # 最后输出i，就是框里最少有多少个鸡蛋了；
6、逻辑运算
逻辑运算符包括：逻辑与（and）、逻辑或（or）、逻辑非（not）
短路逻辑是什么？
短路逻辑是指在逻辑与或运算中，当已经可以确定整个表达式的值时，后续的运算将不再执行。
在逻辑与（and）运算中，如果第一个操作数为假，那么无论第二个操作数是真还是假，整个表达式的值都为假（False），因此第二个操作数将不会被执行。
同样，在逻辑或（or）运算中，如果第一个操作数为真，那么无论第二个操作数是真还是假，整个表达式的值都为真（True），因此第二个操作数将不会被执行。
这种短路特性可以节省计算资源，并且在实际的编程中经常被用来优化代码。
6.1 逻辑与 运算
and 表示只有两个操作数都为True时，才返回True；否则都返回False。
- 图解：
| 第一个操作数 | 第二个操作数 | 运算结果 |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
逻辑与是一种短路逻辑，如果左侧表达式为 False，则直接短路返回结果，不再运算右侧表达式。 因此，在设计逻辑运算时，应确保逻辑运算符左侧的表达式返回值足一个可以预测的值。右侧表达式不应包含有效运算，如函数调用等，因为当左侧表达式为 False 时，则直接跳过右侧表达式，给正常运算带来不确定性。
总的来说，只有左侧是False，那么返回一定是False。
- 【示例】设计用户管理模块，对用户身份进行判断；
1级为“游客”；
2级为“会员：普通会员”；
3级为“会员：高级会员”；
4级为“会员：超级会员”；
5级为“管理员”；
输入其他，则输出："无效输入，请输入正确的级别号（1-5）！"
使用多分支结构设计如下。
#设计用户管理模块，对用户身份进行判断。使用多分支结构设计如下。
grade = int(input("请输入你的级别："))
if grade == 1:
print("游客")
elif grade == 2:
print("会员：普通会员")
elif grade == 3:
print("会员：高级会员")
elif grade == 4:
print("会员：超级会员")
elif grade == 5:
print("管理员")
else:
print("无效输入，请输入正确的级别号（1-5）！")
print("-----"*55)
# 使用逻辑运算来写，如下：
grade1 = int(input("请输入你的级别："))
str = (grade1 == 1 and "游客" or
grade1 == 2 and "会员：普通会员" or
grade1 == 3 and "会员：高级会员" or
grade1 == 4 and "会员：超级会员" or
grade1 == 5 and "管理员" or
"无效输入，请输入正确的级别号（1-5）！")
print(str)
6.2 逻辑或 运算
or 表示两个操作数中只要有一个为True，就返回True；否则就返回False。
- 图解：
| 第一个操作数 | 第二个操作数 | 运算结果 |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
逻辑或也是一种短路逻辑：如果左侧表达式为 True，则直接短路返回结果，不再运算右侧表达；
- 【示例】 假设某校招特长生，设定如下了个招生标准：
第一类，如果钢琴等级在 9 级或以上，且计算机等级在 4 级或以上，则直接通过：；
第二类，如果文化课非常优秀（90分及以上），可以适当降低特长标准，钢琴等级在 5 级或以上，且计算机拿 2 级或以上；
第三类，如果文化课及格（60分及以上，90分以下），则按正常标准录取，钢琴等级在 7 级或以上，且计算机等级在3级或以上。
根据上述设定条件，编写简单的特招录取检测程序如下。
# 首先，找出上述所需的条件都有哪些：考号、文化课成绩、钢琴等级、计算机等级
# 其次，要求用户输入自己的成绩
id = int(input("请输入自己的考号："))
if id > 20230601 and id < 20232000:
print("符合招生条件，请填成绩单！")
culture = int(input("请输入自己的文化课成绩："))
piano = int(input("请输入自己的钢琴等级："))
computer = int(input("请输入自己的计算机等级："))
# 判断：钢琴大于等于9级并且计算机大于等于4级，录取；或者；文化大于等于90并且钢琴大于等于5级并且计算机大于等于2级，录取；或者；文化大于等于60并且小于90（合格）并且钢琴大于等于7级并且计算机大于等于3级，录取。
if (piano >= 9 and computer >= 4) or (culture >= 90 and piano >= 5 and computer >= 2) or (culture >= 60 and culture < 90 and piano >= 7 and computer >= 3):
print("恭喜被我校录用！！！")
else:
print("很遗憾，您被淘汰了！")
else:
print("不符合招生条件！")
上述示例仅做测试数据，不可用到生活中，如需用到生活中，需要改一些代码；因为：我这还有一些漏洞的，比如：成绩和等级没有上限和下限，只有高于。
6.3 逻辑非 运算
not 仅包含一个操作数，表示把操作数转换为布尔值，然后返回取反后的布尔值。
逻辑与 和 逻辑或 运算的返回值不必是布尔值，但是逻辑非运算的返回值一定是布尔值，而不是表达式的原值；
【示例】逻辑非运算，如果执行两次逻辑非运算操作，相当于把操作数转换为布尔值；
print(not 0) # 返回True
print(not not 0) # 返回False
print(not not not 0) # 返回True
print(not not not not 0) # 返回False
print(not False) # 返回True
print(not None) # 返回True
print(not "") # 返回True7、位运算
位运算符一共有6个，分为如下两类：
- 逻辑位运算：位与（&）、位或（|）、位异或（^）、位非（~）
- 移位运算：左移（<<）和右移（>>）
7.1 逻辑位运算
- 图解1：& 位与运算符
& 运算符表示，对两个二进制操作数逐位进行比较。在位运算中，True代表的1，False代表的是0。和上述的是一个道理；
| 第一个数值 | 第二个数值 | 运算结果 |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
- 图解2：| 位或运算符
| 运算符表示，对两个二进制操作数逐位进行比较。和上述的 是一个道理；
| 第一个数值 | 第二个数值 | 运算结果 |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
- 图解3：^ 位异或运算符
^ 运算符表示，对两个二进制操作数逐位进行比较。
只要第一个数值和第二个数值不一样（一个1或一个0），则运算结果为1（True）；相反，数值1和数值2结果相同时，运算结果为0（False）
| 第一个数值 | 第二个数值 | 运算结果 |
|---|---|---|
| 1 | 1 | 0 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
- 图解4：~ 位非运算符
~ 运算符表示，对一个二进制操作数逐位进行取反操作。
【示例】使用位运算对用户输入的数字进行加密。加密过程如下：
第1步：先接收用户输入的数字（仅接收整数）；
第2步：对数字执行左移5位运算符；（为运算为超纲，在下一小节来着，不过前面已经说了移位符号，那么应该可以理解的；）
第3步：在对移位后的数字执行按位取反运算；
第4步：去掉负号。
password = int(input("请输入一个数字（仅接收整数）："))
print("你输入的数字为：%s"%password) # %s占位符，%password将值给到占位符
new_password = -(~(password << 5)) # -为去掉负号，~为取反，<< 5 为向左偏移5.
print("对数字执行左移5位运算符结果为：%s"%new_password)
old_password = -(~(new_password)) >> 5 # -为去掉负号，~为取反，<< 5 为向右偏移5.
print("在对移位后的数字执行按位取反运算结果为：%s"%old_password)
7.2 移位运算
在移位运算过程中，符号位始终保持不变，如果右侧空出位置，则自动填充为0；如果超过32为值，则自动丢弃。
与左移位运算相反；它吧32位的二进制数中的所有有效位整体右移，再使用符号位的值填充空位。移动过程中超出的值将被丢弃。
【示例1】左移位
# 5向左移位2
5 << 2 # 结果为20
#我们可以看一下
bin(5)
5的二进制为：0b101
bin(20)
20的二进制为；0b10100
5向左移位2位，二进制数加两个0，所以结果为0b10100，所以最终结果为：20【示例2】右移位
# 5向右移位2
5 >> 2 # 结果为1
#我们可以看一下
bin(5)
5的二进制为：0b101
bin(1)
1的二进制为；0b1
5向右移位2位，二进制数减两位，所以结果为0b1，所以最终结果为：1【示例3】设计输入一个正整数，求这个正整数转化为二进制数后1的个数。
设计思路：假设一个整数变量number，number& 1 有两种可能：1或0。当结果为1时，说明最低位为1；当结果为0时，说明最低位为0。可以通过>>运算符右移一位，再求number& 1，直到number为0。
while True:
count = 0 # 定义变量统计 1 的个数
number = int(input("请输入一个正整数：")) # 输入一个正整数
temp = number # 备份输入的数字
if number > 0: # 输入正整数时
while True: # 无限次循环
if number & 1 == 1: # 最后一位为1
count += 1 # 统计1 的个数
number >>= 1 # 右移一位，并赋值给自己
if number == 0: # 数位0时
break # 退出循环（break什么意思后面会讲，这里只要知道他是退出的意思就行）
print(temp,"的二进制数中1的个数为：",count) # 打印结果
else: # 输入非正整数时
print("输入的数不符合规范") # 打印提示语句
8、其他运算
其他运算符一共有4个，分为如下两类：
成员运算：in 、 not in
身份运算：is 、 is not
in：表示是否是成员；适用于：字符串、列表、元组
is：比较两个对象是否相同（内存地址是否相等）
== ： 比较两个对是否相等（对象的值和类型是否相等）
8.1 成员运算
成员运算符包含两种：in 和 not in
- 图解：
| 运算符 | 描述 | 示例 |
|---|---|---|
| in | 如果在指定的对象中 找到元素值，则返回True，否则返回False | str = "adfasdfa" print ("a" in str) # 返回True |
| not in | 如果在指定的对象中 没有找到元素值，则返回True，否则返回False | str = "adfasdfa" print ("a" not in str) # 返回True |
- 【示例1】运算符 in 示例：
输出 a ，在str中寻找，找到了，则返回True。
str = "adfasdfa"
print ("a" in str) # 返回True- 【示例2】运算符 not in 示例：
输出 a ，在str中寻找，找到了，则返回False。
str = "adfasdfa"
print ("a" not in str) # 返回False【示例3】检测用户输入的数字是否已经存在指定的列表中；
存在，则继续输入 或者退出。
不存在，则附加到列表中，并询问是否继续或退出；不加解析
list = [1,2,3,4,5,6,7,8,9]
while True:
num = int(input("请输入一个数字："))
if num in list:
print("输入的数字已经存在啦！")
else:
list.append(num)
print("不存在，输入的数字将被添加到列表中哈！")
ok = input("输入的数字存在，是否继续输入：（y/n）")
if ok == "y":
continue
elif ok == "n":
print(list)
break
else:
print("输入的字符有误，退出程序，如要继续运行，请重新开始")
break- 加解析
# 定义一个列表（后面会学到，【字典与集合】）
list = [1,2,3,4,5,6,7,8,9]
# 使用无限循环检测用户输入的数字
while True:
# 检测用户输入的数字
num = int(input("请输入一个数字："))
# 判断：如果用户输入的数字（num）有上面定义的列表（list）中的值，则返回存在，并询问是否继续或退出；没有则返回：不存在，则附加到列表中。
if num in list:
print("输入的数字已经存在啦！")
else:
list.append(num)
print("不存在，输入的数字将被添加到列表中哈！")
# if 判断完毕，将会询问是否继续，如果继续，则继续while操作；如果退出，则输出list所有的值：包括不存在后自动加进去的值，并退出；如果输入的其他值，则会提示并停止运行
ok = input("输入的数字存在，是否继续输入：（y/n）")
if ok == "y":
continue
elif ok == "n":
print(list)
break
else:
print("输入的字符有误，退出程序，如要继续运行，请重新开始")
break
8.2 身份运算
身份运算包含2个运算符；
主要用于比较两个对象的内存地址是否相同。is 用于判断变量的引用地址是否相等，==运算符判断变量的类型和值是否相等。使用id()函数可以获取引用地址，因此：a is b 相当于 id(a) == id(b)
- 图解：
| 运算符 | 描述 |
|---|---|
| is | 判断两个标识符是否引用同一个对象 |
| is not | 判断两个标识符是否引用不同的对象 |
- 【示例1】运算符 is 示例：
判断a 和 b的值是否一样，一样输出：True，不一样输出：False
a = 1
b = 2
print(a is b) # 结果为False- 【示例2】运算符 is not 示例：
判断a 和 b的值是否一样，一样输出：False，不一样输出：True
a = 1
b = 2
print(a is not b) # 结果为True- 【示例3】出于性能考虑，凡是不可变对象，只要值相同，Python 就不会重复创建，而是引用己存在的对象。 因此，对于不可变对象来说，如果两个值相同，使用 is 可以判断它们是否是同一个对象。例如：
a = 1 # 定义字符串a=1
b = 1 # 定义字符串b=1
print(a is b) # 输出 a 是否等于 b，结果为：True
print(id(a)) # 输出a的id
print(id(b)) # 输出b的id
print(a == b) # 判断a的id是否等于b的id，结果为：True简单来说，只要值是一样的，他们的id就是一样的，不会重复创建，利于性能。
- 【示例4】假设 n 是一个任意的自然数，若将 n 的各位数字反向排序所得自然数 n1 与 n 相等，则称 n 为回文数。
例如：如果 n =123123，则称 n 为回文数；但如果n = 123456，则不为回文数。
num1 = num2 = int(input("请输入一个自然数：")) # 输入一个自然数
t = 0 # 设置中间变量
while num2 > 0: # 输入数据大于0时
t = t*10+num2 % 10 # 将数据尾数依次存入t中
num2 //= 10 # 数据取整
if num1 == t: # 反向排列的数与原数相等
print(num1,"是一个回文数") # 输出的是回文数
else: # 反向排列的数与原数不相等
print(num1,"不是一个回文数") # 输出的不是回文数9、案例实战
下面为结合本章的知识来提出的一些案例实战，可能会有超纲的内容，可以先大概的看一下，等到学完，我会专门整理一个所有课程案例实战的文章，供大家参考，到时候看所有案例都知道是什么意思了。
9.1 模拟进度条
通过格式化输出的方式，可以模拟加载进度条。
提示：主要使用time模块的sleep()函数模拟加载的进度，然后使用for语句逐步打印进度显示条。
- 不加解析
import time
length = 100
for i in range(1,length + 1):
percetange = i / length * 100
block = '#' * int(i // (length / 20))
time.sleep(0.1)
print('\r加载条：|{:<20}|{:>6.1f}%'.format(block,percetange),end="")- 加解析
# 导入time模块
import time
# 定义长度变量
length = 100
# 循环遍历1-100的数，从1开始，每次加1
for i in range(1,length + 1):
# 计算进度条的百分比，当前循环的数（i）除以length然后乘以100。
percetange = i / length * 100
# 计算进度条的个数
block = '#' * int(i // (length / 20))
# 让程序停止0.1秒，可以让我们更好的看到加载的效果
time.sleep(0.1)
# 格式化输出，打印出加载条和百分比。
print('\r加载条：|{:<20}|{:>6.1f}%'.format(block,percetange),end="")
# 比如i为1时：
# for循环 i = 1
# percetange计算为：1 / 100 * 100 从左到右 = 0.1*100 = 1.0（计算出来结果为浮点数，所以带个.）
# block计算为：'#' * int(1 // (100 / 20)) 代表的是进度条为100，每余5则为一个#号，计算为：1 // (5) = 0，所以1没有输出#号
# time.sleep(0.1) 停止0.1秒继续运行，可以让我们更好的看到加载的效果
# 输出：\r为回车符号，回车后会回到开头，并将前面的输出全部覆盖在输出，形成动态更新的效果，如果不添加的话，就会一直横着输出，感兴趣的可以自己试一试；
# '{:<20}'和'{:>6.1f}%'是格式化字符串，分别表示左对齐的20个字符宽度的字符串和至少有6个字符宽度、小数点后有1位的浮点数并加上百分号。
# 比如i为5时：
# for循环 i = 5
# percetange计算为：5 / 100 * 100 从左到右 = 0.5*100 = 5.0（计算出来结果为浮点数，所以带个.）
# block计算为：'#' * int(5 // (100 / 20)) 代表的是进度条为100，每余5则为一个#号，计算为：5 // (5) = 1，所以会输出一个#号
# time.sleep(0.1) 停止0.1秒继续运行，可以让我们更好的看到加载的效果
# 输出：\r为回车符号，回车后会回到开头，并将前面的输出全部覆盖在输出，形成动态更新的效果，如果不添加的话，就会一直横着输出，感兴趣的可以自己试一试；
# '{:<20}'和'{:>6.1f}%'是格式化字符串，分别表示左对齐的20个字符宽度的字符串和至少有6个字符宽度、小数点后有1位的浮点数并加上百分号。
9.2 统计学生成绩
设计程序计算学生语文成绩的平均分，筛选出优秀生名单，输出最高分。
提示：使用字典结构来记录学生成绩，通过len() 函数获取字典包含学生总人数。
- 不加解析
name_cj = {
"张三":89,
"李四":76,
"王五":95,
"赵六":66,
"侯七":77,
"老八":99
}
sum = 0
max = 0
max_name = ""
print("语文成绩优秀生名单：")
for i in name_cj:
sum += name_cj[i]
if name_cj[i] >= 85:
print("%s(%.2f)"%(i,name_cj[i]))
if name_cj[i] > max:
max = name_cj[i]
max_name = i
print()
print("语文平均分为：%2.f" %(sum/len(name_cj)))
print("语文最高分为：%2.f(%s)"%(max,max_name))- 加解析
# 定义一个字典结构，内含：姓名及语文成绩（字典结构后面会学到）
name_cj = {
"张三":89,
"李四":76,
"王五":95,
"赵六":66,
"侯七":77,
"老八":99
}
# 总分：初始值为0
sum = 0
# 最高分：初始值为0
max = 0
# 最高分的姓名：初始值为空
max_name = ""
# 输出语文成绩优秀生名单，但是到这块还不会输出任何值
print("语文成绩优秀生名单：")
# 开始一个for循环，遍历字典name_cj字典。在每次循环中，i都会是字典的一个键，也就是一个学生的名字和成绩。
for i in name_cj:
# 将当前学生的语文成绩加到sum上，迭代成绩表
sum += name_cj[i]
# 判断，如果当前学生的语文成绩大于等于85，那么打印出他们的名字和成绩，也就是过滤出优秀的学生。
if name_cj[i] >= 85:
print("%s(%.2f)"%(i,name_cj[i]))
# 判断，如果当前学生的语文成绩大于max（也就是目前的最高成绩），那么更新max和max_name，以便记录新的最高成绩和对应的学生名字。
if name_cj[i] > max:
# 过滤最高分
max = name_cj[i]
# 过滤最高分的学生的姓名
max_name = i
# 输出一个空行，用来区分，自己也可以用其他来带代替；
print()
# 输出平均分；这是通过计算sum（所有成绩的总和）除以学生数量得到的。
#%2.f在Python语言中是一个字符串格式化的指令，它表示一个浮点数(float)的占位符。其中，'.'后的'2'代表小数点后的位数。因此，'%2.f'将sum/len(name_cj)的结果转化为一个保留两位小数的浮点数。
print("语文平均分为：%2.f" %(sum/len(name_cj)))
# 输出语文最高分和最高分的姓名
print("语文最高分为：%2.f(%s)"%(max,max_name))
9.3 逐位推算
如果输入一个尾数是 3 或者 9 的数字，判断至少需要用含有多少个9的数字才能整除该数。
- 不加解析
divsior = int(input("请输入一个数字[末尾是 3 或 9 的数字]："))
flag = True
count = 1
num = 9
dividend = 9
while flag:
if dividend % divsior == 0:
flag = False
else:
num *= 10
dividend += num
count += 1
print('{}个9可以被{}整除'.format(count,divsior))
r = dividend / divsior
print('{}/{} = {}'.format(dividend,divsior,r))- 加解析
# 定义一个变量叫divsior，接收一个尾数为 3 或 9 的数字
divsior = int(input("请输入一个数字[末尾是 3 或 9 的数字]："))
# 定义标记变量，初始值设置为：True；此变量用于控制接下来的 'while' 循环。
flag = True
# 定义统计变量，值为 '1'。此变量用于跟踪需要多少个9才能被 'divsior' 整除。
count = 1
# 定义常数9，此变量用于构建可被 'divsior' 整除的数字。
num = 9
# 定义变量 'dividend'，值为 '9'。这是我们将尝试被 'divsior' 整除的数字。
dividend = 9
# 循环判断；只要 'flag' 为 'True'，就会执行这个循环。循环的目标是找到一个数字，该数字由足够多的9组成，可以被 'divsior' 整除。
while flag:
# 检查 'dividend' 是否可以被 'divsior' 整除。如果可以，则 'flag' 设置为 'False'，结束循环。
if dividend % divsior == 0:
flag = False
# 如果 'dividend' 不能被 'divsior' 整除，则执行下面的代码。
else:
# 将 'num' 的值乘以10，为在下一次循环迭代中增加一个新的9做准备。
num *= 10
# 将 'num'（当前为9）添加到 'dividend'。
dividend += num
# 由于我们添加了一个9到 'dividend'，所以我们需要增加计数器。
count += 1
# 此行打印出需要多少个9才能被 'divsior' 整除。
print('{}个9可以被{}整除'.format(count,divsior))
# 计算并存储商。
r = dividend / divsior
# 打印出被除数、除数和商。
print('{}/{} = {}'.format(dividend,divsior,r))
# 其他解析：
# {}在Python中是格式化字符串的占位符，它会被.format()方法中对应位置的参数替代。
# .format()方法是Python中的一个字符串方法，用于格式化字符串。它将传入的参数插入字符串中的{}占位符位置。
9.4 数字运算器
设计一个简单的四则运算器，允许用户输入两个数字和四则运算符，然后返回运算结果。
四则运算器是什么？
四则运算器是指可以进行加、减、乘、除运算的计算器，被称为：四则运算器。
- 无解析
while True:
number1 = int(input("请输入第一个数字："))
x = input("请输入【+ - * /】：")
number2 = int(input("请输入第二个数字："))
operator = {
'+':number1 + number2,
'-':number1 - number2,
'*':number1 * number2,
'/':number1 / number2
}
result = operator.get(x,'输入运算符 + - * / ：')
print("运算结果为：%d"%result)
print("---"*6)
Continue = input("是否继续计算？（y/n）")
if Continue == "y":
continue
elif Continue == "n":
break
else:
print("输入有误，退出计算器")- 加解析
# 创建一个无限循环
while True:
# 提示用户输入第一个数字，并将其转换为整数类型，然后存储在变量number1中。
number1 = int(input("请输入第一个数字："))
# 提示用户输入一个运算符，可以是'+'，'-'，''或'/'，然后存储在变量x中。
x = input("请输入【+ - * /】：")
# 提示用户输入第二个数字，并将其转换为整数类型，然后存储在变量number2中。
number2 = int(input("请输入第二个数字："))
# 创建了一个字典，键是运算符，值是对应的运算结果。
operator = {
'+':number1 + number2,
'-':number1 - number2,
'*':number1 * number2,
'/':number1 / number2
}
# 从字典中获取与用户输入的运算符对应的运算结果。如果用户输入了无效的运算符，则返回提示信息。
# operator.get是什么意思？答：这是Python语言中的字典（dictionary）的get方法。字典是一种存储键值对（key-value pairs）的数据结构。
# 在这个例子中，operator是一个字典，x是要查找的键。如果x在字典中，则get方法会返回对应的值；如果x不在字典中，则get方法会返回'输入运算符 + - * / ：'这个默认值。
result = operator.get(x,'输入运算符 + - * / ：')
# 打印运算结果：%d为占位符，%result为查找字典中的计算结果；
print("运算结果为：%d"%result)
# 输出---在*6个--，用来做分割用的，可有可无，为了观看方便，所以就加上了；后续不需要可以去掉的。
print("---"*6)
# 这里提示一下：定义变量Continue不能用小写的continue，会报错；
# 提示用户是否要继续计算，
# 继续输入y：然后返回继续计算；
# 不继续输入x：然后退出程序；
# 输入的不是 y 或者 n ，则提示：输入有误，退出计算器。
Continue = input("是否继续计算？（y/n）")
if Continue == "y":
continue
elif Continue == "n":
break
else:
print("输入有误，退出计算器")
break
讲到这里就完成了第八篇《Python的表达式》，接下来我还会持续输出Python学习文章，大家可以订阅我的专栏：《python 学习》
🐋 希望大家多多支持，我们一起进步！😄
🎉如果文章对你有帮助的话，欢迎 点赞 👍🏻 评论 💬 收藏 ⭐️ 加关注+💗