使用Python编写游戏自动化脚本及自动办公02.数值类型、运算符、条件分支
# **数值类型****上一堂课我们学习了Python变量的定义不需要指定类型,让Python的变量看起来更像是名字标签,想贴哪儿就贴哪儿。通过这个标签,就可以轻易找到变量在内存中对应的存放位置。但这绝不是说Python就没有数据类型这回事儿,大家应该还记得字符串和非字符串运算的"大坑"。**
**虽然Python在变量定义的时候不需要显示指定类型,但是在内存中存储的数据是有具体类型的,只是这个工作Python悄悄完成了,我们感觉不到而已。例如在内存中:一个人的姓名是字符串类型、年龄是数值类型,婚姻状况是布尔类型。这里的字符串类型、数值类型、布尔类型都是 Python 语言中提供的基本数据类型。**
**我们先来学习Python的数值类型,Python数值类型有4种:**
**int (整数类型)**
**float (浮点类型)**
**complex (复数类型)**
**bool (布尔类型)**
**注意:布尔类型也是数值类型,事实上布尔类型是整数类型的一种。**
## **整型**
**整型就是平时所见的整数,用来表示整数数值,即没有小数部分的数值。**
**Python3 的整型已经与长整型进行了无缝结合,现在 Python3 的整型类的长度不受限制,具体能到多大,就看大家电脑的配置了,因为最大只受所在计算机硬件的限制。所以,在 Python3 中可以很容易地进行大数运算。**
```
# 有个小宝宝今年3岁,马上就过年了,过完年小宝宝就4岁了,我们来温习一下变量并计算一下
小宝宝年龄 = 3
小宝宝年龄 = 小宝宝年龄 + 1
print(f'过完年小宝宝就 {小宝宝年龄} 岁啦') # 别急这种输出方式马上就会讲到
# 天文学家保守估计,宇宙中的星系数量可能会达到1万亿个。而保守估计,每一个星系当中有1000万亿颗恒星,算一算目前人类观测到的宇宙里大概有多少颗恒星?
# 这在以前是需要写算法去实现的!但是在Python中,so easy。
宇宙恒星数量 = 10000000000123 * 10000000000000456
print(f'目前人类观测到宇宙的恒星数量大概有 {宇宙恒星数量} 颗')
```
#**运行结果**
**过完年小宝宝就 4 岁啦**
**目前人类观测到宇宙的恒星数量大概有 100000000001234560000000056088 颗**
> **注意:Python中整数类型(int)包括十进制整数、八进制整数、十六进制整数和二进制整数,简单说就是一个整数有不同的表示方式,我们习惯性的使用十进制的整数,而在计算机中所有的数据都是用二进制(0和1)表示。**
## **浮点型**
**浮点型就是平时所说的小数,例如,圆周率3.14就是一个浮点型数据,再例如地球到太阳的距离约1.5亿千米,也是一个浮点型。Python中 区分整型和浮点型的唯一方式,就是看有没有小数点。**
**谈到浮点型,就不得不说一下E记法。E记法也就是平时所说的科学计数法,用于表示特别大和特别小的数。打个比方,如果给Python提供一个非常极端的数据,那么它可能会采用E记法来表示。**
```
# 足球世界里 梅西身价: 7000万欧元, 中国武磊:400万欧元, 梅西值多少个武磊 - -梅西身价 = 7000.0
武磊身价 = 400.0
梅西值多少个武磊 = 梅西身价 / 武磊身价
print(f'梅西值 {梅西值多少个武磊} 个武磊')
# 地球到太阳距离大概1.5亿公里,大概多少微米呢,用浮点数表示一下地日距离 = 1.5 * 100000000 * 1000 * 1000000
print(f'地日距离大约 {地日距离} 微米')
# 运行结果
梅西值 17.5 个武磊
地日距离大约 1.5e+16 微米
```
**1.5e+16(大写的E或小写的e都可以)。**
其实大家应该已经发现了,这个E的意思是指数,指底数为10,E后边的数字就是10的多少次幂(如果实在不懂好像也没什么关系!)。
## **复数类型**
**整数和浮点数(小数)在数学中被统称为实数。与实数对应的是复数。**
**复数在数学中被表示为:a+bi,其中a被称为实部,b被称为虚部,i 被称为虚数单位。复数在数学、理论物理学和电气工程等方面应用广泛,例如向量就可以使用复数表示。
!(data/attachment/forum/202503/09/182523he842alw9sje9rtn.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103120229220.png")
**Python 中的复数与数学中的复数的形式完全一致,都是由实部和虚部组成,并且使用 j 或 J 表示虚部。当表示一个复数时,可以将实部和虚部相加,例如,一个复数,实部为 3.14,虚部为 12.5j,则这个复数为 3.14+12.5j。**
**我们平时使用复数的场景很少,大家了解一下就可以了。**
## **布尔类型**
**人们常说“小孩才分对错,大人只看利弊”,计算机却一直坚持是非分明。在Python中,布尔类型主要用来表示真值或假值,,标识符 True 和 False 被解释为布尔值。另外,Python 中的布尔值可以转换为数值,True 表示 1, False 为 0(Python 中的布尔类型的值可以进行数值运算,例False+1 的结果为 1,把布尔类型当成 1 和 0 来参与运算这种做法是不妥的,容易引起代码的混乱,最好不要这么用!)。**
**在Python中,所有的对象都可以进行真值测试。其中,只有下面列出的几种情况得到的值为假,其他对象在 if 或者 while 语句中都表现为真:**
**False 或 None。**
**数值中的零,包括 0、0.0、虚数 0j。**
**空序列,包括字符串、空元组、空列表、空字典。**
**自定义对象的实例,该对象的 bool() 方法返回 False,或者 len() 方法返回 0。**
**例如,1 + 1 > 3,我们都知道是错的,Python也知道:**
```
# 小宝宝说 1 加 1 等于 3, 一起来看一下是否正确?
x = 1 + 1 > 3 # 这里涉及到计算赋值 和 操作符的优先级,稍后会讲到
y = 1 + 1 == 2
print(f'小宝宝说 1 + 1 > 3 : {x}')
print(f'我说 1 + 1 = 2 : {y}')
# 结果:
小宝宝说 1 + 1 > 3 : False
我说 1 + 1 = 2 : True
```
## **数值类型的相互转换**
**很多数值类型的数据都可以被转换为布尔值,那么数值类型是否也可以相互转换呢?**
Python中的很多数据类型都可以相互转换,但是具体情况比较复杂,本章重点介绍数值类型之间的相互转换。
在Python的数值类型中,除复数外,其他三种数值类型如整数、浮点和布尔都可以相互转换,分为隐式类型的转换和显式类型的转换。
### **隐式类型的转换**
数字之间可以进行数学计算,在进行数学计算时若数值类型不同,则会发生隐式类型的转换,规则如下图所示:
!(data/attachment/forum/202503/09/182545pn5cf000yhek3dhc.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103120806859.png")
**来一起看看示例:**
```
结果 = 1 + True # 布尔值True被转换成整数
print(f'1 + True = {结果}')
结果 = 1.0 + 1 # 整数1被转换成浮点数
print(f'1.0 + 1 = {结果}')
结果 = 1.0 + True # 布尔值True被转换成浮点数
print(f'1.0 + True = {结果}')
结果 = 1.0 + 1 + True # 整数1和布尔值True都被转换成浮点数
print(f'1.0 + 1 + True = {结果}')
\# 运行结果
1 + True = 2
1.0 + 1 = 2.0
1.0 + True = 2.0
1.0 + 1 + True = 3.0
```
### **显式类型的转换**
!(file:///E:/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/Python%E4%BF%AE%E7%82%BC%E7%A7%98%E7%B1%8D/notesimg/image-20241103120852899.png?lastModify=1741515628)
**Python 的显示转换实际上并没有把一个东西从一种类型“转换”成另一种类型。它只是由原来的东西创建一个新东西,而且这个新东西正是你想要的类型。int()、float()、bool()函数可以指定把数据从一种类型转换为另一种类型。**
**一起来看示例:**
```
结果 = int(1.0) + 1
print(f'int(1.0) + 1 = {结果}')
结果 = int(6.6)
print(f'int(6.6) = {结果}')
x = int(False)
y = int(True)
print(f'int(False) = {x}, int(True) = {y}')
结果 = float(6)
print(f'float(6) = {结果}')
x = float(False)
y = float(True)
print(f'float(False) = {x}\nfloat(True) = {y}')
a = bool(0)
b = bool(0.0)
c = bool(2)
d = bool(6.6)
print(f'bool(0) = {a}\n bool(0.0) = {b}\n bool(2) = {c}\n bool(6.6) = {d}')
# 运行结果
int(1.0) + 1 = 2
int(6.6) = 6
int(False) = 0, int(True) = 1
float(6) = 6.0
float(False) = 0.0
float(True) = 1.0
bool(0) = False
bool(0.0) = False
bool(2) = True
bool(6.6) = True
```
# **运算符**
**刚刚我们学习了Python的数值类型,有了数据,我们就可以通过运算符把它们连接起来,形成表达式,进而通过表达式进行运算,最后得到一个结果,大家有没有发现这和小学学过的数学运算非常的相似,没错,原理是一样的。**
## **算术操作符**
**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 // 2 = 4 -9 // 2 = -5** |
**看示例:**
```
# 算术操作符 ( +-*/)就不演示了大家可以自行尝试一起来看看:( %**// ) x = 15 % 6
print("15 % 6 的值为:", x)
x = 3 ** 4
print("3 ** 4 的值为:", x)
x = 16 // 7
print("16 // 7 的值为:", x)
# 运行结果
15 % 6 的值为: 3
3 ** 4 的值为: 81
16 // 7 的值为: 2
```
## **赋值运算符**
**以下假设变量a为 2,变量b为 3:**
| **运算符** | **描述** | **实例** |
| ------------ | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **=** | **简单的赋值运算符** | **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)")** |
**看示例:**
```
a = 5
y = 23
y += a
print(y)
y *= a
print(y)
y %= a
print(y)
#运行结果注意:y的值是一直在变化的
28
140
0
```
## **比较运算符**
**以下假设变量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。** |
**看示例:**
```
print("8 == 13 : ", a == b)
print("8 != 13 : ", a != b)
print("8 > 13 : ", a > b)
print("8 < 13 : ", a < b)
#运行结果
8 == 13 : False
8 != 13 : True
8 > 13 : False
8 < 13 : True
```
!(data/attachment/forum/202503/09/182605vnbyso5s7x08gg25.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103121424244.png")
## **逻辑运算符**
**Python语言支持逻辑运算符,以下假设变量 a 为 0, b为 1:**
| **运算符** | **逻辑表达式** | **描述** | **实例** |
| ------------ | ---------------- | -------------------------------------------------------------------------------------------- | ---------------------------- |
| **and** | **x and y** | **布尔"与"当x 和 y 都为 True 时返回 True,否则返回False** | **a and b 返回 False。** |
| **or** | **x or y** | **布尔"或"当 x 和 y 都为 False 时返回 False,否则返回True** | **a or b 返回 True。** |
| **not** | **not x** | **布尔"非" 把 not 理解为杠精,一定要反着来 x 为 True 返回 False, x 为 False 返回 True。** | **not(a and b) 返回False** |
**示例:**
```
x = True
y = False
print("True and False : ", x and y)
print("True or False : ", x or y)
print("not False : ", not y)
print("not True : ", not x)
#运行结果
True and False : False
True or False : True
not False : True
not True : False
```
## **优先级问题**
**当一个表达式存在多个运算符的时候,可能出现以下情况:**
**加法运算符说:“我先到的,我先计算!”**
**乘法运算符说:“哥我运算一次够你翻几个圈了,哥先来!”**
**减法运算符说:“你糊涂了,我现在被当成负号使用,没有我,你们再努力,结果也是得到相反的数!”**
**除法运算符这时候默默地说:“抢吧抢吧,我除以零,大家同归于尽!”**
为了防止以上矛盾的出现,我们规定了运算符的优先级,当多个运算符同时出现在一个表达式的时候,严格按照优先级规定的级别来进行运算。
**先乘、除,后加、减,如有括号先运行括号里边的。没错,从小学我们就学到了运算符优先级的精髓,在编程中也是这么继承下来的。不用刻意去背。当然,在适当的地方加上括号强调一下优先级,我觉得会是更好的方案。**
**以下表格列出了从最高到最低优先级的所有运算符:**
| **优先级** | **运算符** | **描述** |
| ------------ | -------------------------------------------- | ------------------------------------------ |
| **1** | **()** | **小括号** |
| **2** | ** | **算术运算符(指数 )** |
| **3** | **~** | **位运算(位反)** |
| **4** | **+, -** | **算术运算符(正负号)** |
| **5** | ***, /, %, //** | **算术运算符(乘,除,求余数和取整除)** |
| **6** | **+, -** | **算术运算符(加、减)** |
| **7** | **>>, <<** | **位运算(右移,左移)** |
| **8** | **&** | **位运算(位与)** |
| **9** | **^** | **位运算(位异或)** |
| **10** | | |
| **11** | **<=, <, > , >=,== , !=** | **比较运算符** |
| **12** | **=, %=, /=, //=, -=, +=, *= ,**=** | **赋值运算符** |
| **13** | **not** | **逻辑运算符(逻辑非)** |
| **14** | **and or** | **逻辑运算符(逻辑与、逻辑或)** |
**以下实例演示了Python所有运算符优先级的操作:**
```
结果 = (2 + 3) * 5 - 80 / 2 ** 3
print("(2 + 3) * 5 - 80/ 2 ** 3 运算结果为:", 结果)
# 运行结果
(2 + 3) * 5 - 80 / 2 ** 3 运算结果为: 15.0
```
**运算步骤如下:**
1. **5 * 5 - 80 / 2 ** 3**
2. **5 * 5 - 80 / 8**
3. **25 - 80 / 8**
4. **25 - 10.0**
5. **15.0**
# **分支语句**
**我们在前面写的代码中大都是一些简单的语句,所写的代码相当于一个命令清单,Python会从上到下的进行执行,一条道走到黑,我们要想把程序设计得更聪明点——比如可以根据不同的条件执行不同的任务,这就是条件分支,学习流程控制方面最基础的条件分支语句 if。**
如何控制程序的流程,使得程序具有“判断能力”,就像人脑一样能够分析问题呢? 首先要分析问题可能存在的各种不同情况,通过对不同情况的判断,让程序根据不同的情况做出相应的处理。
**比如:现在我们要准备编写一个猜数字游戏,游戏的逻辑流程是:**
1. **首先在游戏中随机生成一个0到10的数字。**
2. **提示用户在控制台输入一个数值去和生成的数字进行比较,如果两个数值相等表示猜对,输出“鸿**** ****运当头,恭喜恭喜”。**
3. **输入的数值比生成的数值大的情况输出:“不好意思,您猜大了”,相反则输出:“您猜的有点小”。**
**来一起看个具体情况:**
假设随机生成的数是7,用户输入3,程序输出 “您猜的有点小”;如果用户输入9,程序输出 “不好意思,您猜大了“。
要想完成这个简单的游戏,我们就需要学习使用条件语句 if 结合刚刚学过的比较运算符(>)、小于号(<)以及等于号(==)。
Python 条件语句是通过一条或多条语句的执行结果(True 或者 False)来决定执行的代码块,我们先来看看 if 结构的语法,如下图:
!(data/attachment/forum/202503/09/182639kpjzhf15srp4v5sv.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103121548978.png")
**if 结构执行流程如下图:**
!(data/attachment/forum/202503/09/182655tdtvgqwgbjjqbjgz.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103121828673.png")
**学习了 if 语句,猜数字游戏写起来:**
```
import random
谜底数字 = random.randint(0, 10)
输入的字符串 = input("我设了个数字,你来猜猜看:")
猜测数字 = int(输入的字符串)
if 猜测数字 == 谜底数字:
print("鸿运当头,恭喜恭喜:")
if 猜测数字 > 谜底数字:
print("不好意思,您猜大了,谜底数字是:", 谜底数字)
if 猜测数字 < 谜底数字:
print("您猜的有点小,谜底数字是:", 谜底数字)
```
**上面的程序虽然实现了对情况的判断,但是显得有点木讷呆板,怎么改进呢,来学习一下 if -else 结构,语法如下图:**
!(file:///E:/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/Python%E4%BF%AE%E7%82%BC%E7%A7%98%E7%B1%8D/notesimg/image-20241103121920739.png?lastModify=1741515628)
**if-else 结构执行流程如下图:**
!(file:///E:/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/Python%E4%BF%AE%E7%82%BC%E7%A7%98%E7%B1%8D/notesimg/image-20241103121949395.png?lastModify=1741515628)
**我们来尝试改进一下猜数字游戏:**
```
import random
谜底数字 = random.randint(0, 10)
输入的字符串 = input("我设了个数字,你来猜猜看:")
猜测数字 = int(输入的字符串)
if 猜测数字 == 谜底数字:
print("鸿运当头,恭喜恭喜:")
if 猜测数字 > 谜底数字:
print("不好意思,您猜大了,谜底数字是:", 谜底数字)
else:
print("您猜的有点小,谜底数字是:", 谜底数字)
```
**if-else 结构在处理只有两种条件的情况下非常的方便,像我们猜数字游戏有三种情况的时候可以使用 if 嵌套,所谓 if 嵌套就是在 if 或 else 语句组里面再假如if-else 结构,语法如下:**
```
if 条件表达式1:
if 条件表达式2:
语句块1
else:
语句块2
else:
if 条件表达式3:
语句块3
else:
语句块4
```
**利用 if 嵌套我们可以对猜数字游戏进行改进:**
```
import random
谜底数字 = random.randint(0, 10)
输入的字符串 = input("我设了个数字,你来猜猜看:")
猜测数字 = int(输入的字符串)
if 猜测数字 == 谜底数字:
print("鸿运当头,恭喜恭喜:")
else:
if 猜测数字 > 谜底数字:
print("不好意思,您猜大了,谜底数字是:", 谜底数字)
else:
print("您猜的有点小,谜底数字是:", 谜底数字)
```
**对于猜测数字游戏这种会出现3种的条件的情形下,除了可以使用 if 嵌套还可以使用 if-elif-else 结构(可以理解为是 if 嵌套的缩写模式) ,使用语法如下图:**
**面对猜测数字会出现3种的条件的情形下,该请出 if-elif-else 结构了,使用语法如下图:**
!(data/attachment/forum/202503/09/182714nje82hh85pmnwahz.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "wps2.jpg")
if-elif-else 结构执行流程:
!(data/attachment/forum/202503/09/182734ennfggl187vgld2g.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image-20241103122304368.png")
**有了 if-elif-else 我们再来对猜数字游戏进行改进。**
```
import random
谜底数字 = random.randint(0, 10)
输入的字符串 = input("我设了个数字,你来猜猜看:")
猜测数字 = int(输入的字符串)
if 猜测数字 == 谜底数字:
print("鸿运当头,恭喜恭喜:")
elif 猜测数字 > 谜底数字:
print("不好意思,您猜大了,谜底数字是:", 谜底数字)
else:
print("您猜的有点小,谜底数字是:", 谜底数字)
```
**这样我们就完成了猜数字游戏,使用if-elif-else结构让程序代码的逻辑清晰易读。**
上面学习了条件分支语句的三种结构,条件分支通常会结合比较运算和逻辑运算结合使用,在程序中应用频率非常的高。在使用过程中有一些需要注意的点。
**分支语句使用注意:**
1、每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
支持!!!!
页:
[1]