猜数字小游戏

�� 学习目标

通过本文档的学习，你将能够：

  1. 掌握Python的数值类型及其转换方法
  2. 熟练使用四类运算符进行数据计算
  3. 运用条件分支语句控制程序流程
  4. 独立编写猜数字小游戏

�� 内容导航

数值类型

Python 有4种数值类型，其中前三种最常用：

类型

关键字

说明

示例

整数

int

没有小数部分的数

10, -5, 0

浮点数

float

带小数点的数

3.14, -0.5

布尔

bool

真或假

True, False

复数

complex

复数（较少使用）

3+4j

整数（int）

Python的整数没有大小限制，可以表示任意大的数。

# 整数定义
age = 18
count = -100
big_number = 12345678901234567890  # 再大也没问题

# 不同进制表示
binary = 0b1010      # 二进制，等于十进制10
octal = 0o17         # 八进制，等于十进制15
hexadecimal = 0xFF   # 十六进制，等于十进制255

print(binary)        # 输出: 10

浮点数（float）

浮点数就是小数，Python中使用IEEE 754双精度标准存储。

# 浮点数定义
pi = 3.14159
price = 19.99
negative = -0.5

# 科学计数法
big_num = 1.5e6      # 1.5 × 10^6 = 1500000.0
small_num = 1.5e-6   # 1.5 × 10^-6 = 0.0000015

print(big_num)       # 输出: 1500000.0

⚠️ 注意：浮点数存在精度问题，不要直接比较两个浮点数是否相等！

print(0.1 + 0.2 == 0.3)  # False！因为0.1+0.2=0.30000000000000004

布尔类型（bool）

布尔类型只有两个值：True（真）和 False（假）。

# 布尔值定义
is_student = True
has_permission = False

# 布尔值可以参与数值运算（True=1, False=0）
print(True + 1)      # 输出: 2
print(False * 10)    # 输出: 0
print(True + True)   # 输出: 2

哪些值会被视为False？

在条件判断中，以下值会被当作 False：

  • False、None
  • 0、0.0、0j（所有零值）
  • ''（空字符串）
  • []（空列表）
  • {}（空字典）
  • ()（空元组）

其他所有值都被视为 True。

# 测试布尔转换
print(bool(0))       # False
print(bool(100))     # True
print(bool(""))      # False
print(bool("hello")) # True
print(bool([]))      # False
print(bool([1,2]))   # True

类型转换

Python提供了内置函数进行显式类型转换：

# int() - 转换为整数（截断小数部分）
print(int(3.7))      # 3（不是四舍五入！）
print(int(3.2))      # 3
print(int("42"))     # 42（字符串转整数）
print(int(True))     # 1
print(int(False))    # 0

# float() - 转换为浮点数
print(float(5))      # 5.0
print(float("3.14")) # 3.14

# bool() - 转换为布尔值
print(bool(0))       # False
print(bool(100))     # True

隐式类型转换：运算时Python会自动转换

# 整数和浮点数运算，结果自动转为浮点数
result = 5 + 3.0     # 结果是 8.0
print(type(result))  # <class 'float'>

# 布尔值参与运算
result = True + 5    # 结果是 6（True当作1）

运算符

Python有四类运算符，用于对数据进行各种操作。

算术运算符

用于数学计算：

运算符

名称

说明

示例

结果

+

加

两数相加

5 + 3

8

-

减

两数相减

5 - 3

2

*

乘

两数相乘

5 * 3

15

/

除

两数相除

5 / 2

2.5

//

整除

取商的整数部分

5 // 2

2

%

取余

取除法的余数

5 % 2

1

**

幂

幂运算

2 ** 3

8

# 基础运算
a, b = 17, 5
print(f"a = {a}, b = {b}")
print(f"a + b = {a + b}")      # 22
print(f"a - b = {a - b}")      # 12
print(f"a * b = {a * b}")      # 85
print(f"a / b = {a / b}")      # 3.4（永远是float）
print(f"a // b = {a // b}")    # 3（整除，向下取整）
print(f"a % b = {a % b}")      # 2（17 = 5×3 + 2）
print(f"a ** b = {a ** b}")    # 1419857（17的5次方）

整除的特殊情况：

# 正数整除
print(7 // 3)        # 2

# 负数整除（向负无穷取整）
print(-7 // 3)       # -3（不是-2！）
print(7 // -3)       # -3

实际应用场景：

# 场景1：时间转换
minutes = 125
hours = minutes // 60      # 2小时
remaining = minutes % 60   # 5分钟
print(f"{minutes}分钟 = {hours}小时{remaining}分钟")

# 场景2：判断奇偶
number = 15
if number % 2 == 0:
    print(f"{number}是偶数")
else:
    print(f"{number}是奇数")

# 场景3：循环周期（每3个一组）
for i in range(10):
    group = i // 3         # 当前是第几组
    position = i % 3       # 组内位置
    print(f"i={i}, 第{group}组, 组内位置{position}")

赋值运算符

用于给变量赋值，可以简化代码：

运算符

等价写法

说明

=

x = y

基础赋值

+=

x = x + y

加后赋值

-=

x = x - y

减后赋值

*=

x = x * y

乘后赋值

/=

x = x / y

除后赋值

//=

x = x // y

整除后赋值

%=

x = x % y

取余后赋值

**=

x = x ** y

幂后赋值

x = 10
print(f"初始值: x = {x}")

x += 5       # x = x + 5 = 15
print(f"x += 5 后: x = {x}")

x -= 3       # x = x - 3 = 12
print(f"x -= 3 后: x = {x}")

x *= 2       # x = x * 2 = 24
print(f"x *= 2 后: x = {x}")

x /= 4       # x = x / 4 = 6.0
print(f"x /= 4 后: x = {x}")

比较运算符

用于比较两个值，返回布尔值：

运算符

含义

示例

结果

==

等于

5 == 5

True

!=

不等于

5 != 3

True

>

大于

5 > 3

True

<

小于

5 < 3

False

>=

大于等于

5 >= 5

True

<=

小于等于

5 <= 3

False

age = 18

print(age >= 18)      # True（成年）
print(age == 20)      # False
print(age != 20)      # True

# 比较字符串（按字典序）
print("apple" < "banana")   # True（a在b前面）
print("hello" == "hello")   # True

⚠️ 重要区别：= 是赋值，== 是比较！

x = 5      # 赋值：把5存到变量x中
x == 5     # 比较：判断x是否等于5，返回True或False

逻辑运算符

用于组合多个条件：

运算符

含义

说明

示例

and

与

两边都为True才为True

True and False → False

or

或

一边为True就为True

True or False → True

not

非

取反

not True → False

真值表：

A

B

A and B

A or B

not A

True

True

True

True

False

True

False

False

True

False

False

True

False

True

True

False

False

False

False

True

# 场景1：判断年龄是否在范围内
age = 25
if age >= 18 and age <= 60:
    print("是劳动力")

# 场景2：判断是否是周末
day = "周六"
if day == "周六" or day == "周日":
    print("周末愉快！")

# 场景3：判断是否不是会员
is_member = False
if not is_member:
    print("请先注册会员")

# 场景4：复杂条件
score = 85
attendance = 0.9
if score >= 60 and attendance >= 0.8:
    print("考核通过")

短路求值：

# and：左边为False时，直接返回左边，不计算右边
result = 0 and print("这不会执行")  # result = 0

# or：左边为True时，直接返回左边，不计算右边
result = 1 or print("这不会执行")   # result = 1

# 实际应用：设置默认值
username = ""  # 用户未输入
name = username or "匿名用户"  # 如果username为空，使用默认值
print(name)  # 匿名用户

运算符优先级

当一个表达式中有多个运算符时，按优先级顺序计算：

优先级

运算符

说明

1（最高）

()

括号

2

**

幂运算

3

+x, -x

正负号

4

*, /, //, %

乘除相关

5

+, -

加减

6

==, !=, >, <, >=, <=

比较

7

not

逻辑非

8

and

逻辑与

9（最低）

or

逻辑或

# 示例分析
result = 2 + 3 * 4        # 14（先乘后加）
result = (2 + 3) * 4      # 20（括号优先）
result = 2 ** 3 + 1       # 9（先幂运算：8+1）
result = 10 > 5 and 3 < 4 # True（先比较，后and）

# 不确定时，使用括号
result = (a + b) * c      # 明确优先级

�� 建议：不确定优先级时，多用括号，代码更清晰！

条件分支语句

程序需要根据条件执行不同的代码，这就是条件分支的作用。

基本 if 语句

最简单的条件判断，满足条件就执行：

age = 20
if age >= 18:
    print("你已成年")
    print("可以考驾照了")

print("程序继续执行")

执行流程：

    ┌─────────────┐
    │  age >= 18  │
    └──────┬──────┘
           │
      ┌────┴────┐
      │         │
    True      False
      │         │
      ▼         ▼
┌─────────┐  ┌─────────┐
│ 执行代码 │  │  跳过   │
│ print() │  │         │
└────┬────┘  └────┬────┘
     │            │
     └─────┬──────┘
           ▼
    ┌─────────────┐
    │  继续执行   │
    └─────────────┘

if-else 结构

二选一，满足条件执行A，否则执行B：

age = 16
if age >= 18:
    print("已成年")
else:
    print("未成年")
    print("还需等待", 18 - age, "年")

if-elif-else 结构

多选一，依次判断多个条件：

score = 85

if score >= 90:
    grade = "A（优秀）"
elif score >= 80:
    grade = "B（良好）"
elif score >= 70:
    grade = "C（中等）"
elif score >= 60:
    grade = "D（及格）"
else:
    grade = "F（不及格）"

print(f"成绩等级：{grade}")

⚠️ 注意：条件判断是从上到下依次执行的，一旦某个条件满足，后面的条件就不会判断了！

score = 95

# 错误写法（顺序不对）
if score >= 60:
    print("及格")      # 这里就输出了，后面的不会执行
elif score >= 90:
    print("优秀")      # 永远不会执行

# 正确写法（从高到低）
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")

嵌套 if

在一个if语句中再写if语句：

is_member = True
amount = 150

if is_member:
    if amount >= 100:
        discount = 0.8
        print("会员满100打8折")
    else:
        discount = 0.9
        print("会员打9折")
else:
    discount = 1.0
    print("非会员无折扣")

final_price = amount * discount
print(f"应付金额：{final_price}元")

嵌套 vs 逻辑运算符：

age = 25
income = 8000

# 方法1：嵌套if
if age >= 18:
    if income >= 5000:
        print("符合申请条件")

# 方法2：逻辑运算符（更推荐）
if age >= 18 and income >= 5000:
    print("符合申请条件")

�� 建议：能用逻辑运算符时，尽量避免过多嵌套，代码更易读！

条件表达式（三元运算符）

简单的if-else可以写成一行：

age = 20

# 普通写法
if age >= 18:
    status = "成年"
else:
    status = "未成年"

# 简洁写法（条件表达式）
status = "成年" if age >= 18 else "未成年"

print(status)

语法格式：值1 if 条件 else 值2

实战：猜数字游戏

基础版本

单次猜测，猜完显示结果：

import random

# 生成0-100的随机整数
secret = random.randint(0, 100)

print("=" * 30)
print("   欢迎来到猜数字游戏！")
print("   我想了一个0-100之间的数字")
print("=" * 30)

# 获取用户输入
guess = int(input("\n请输入你的猜测："))

# 判断结果
if guess == secret:
    print("�� 恭喜猜对了！")
elif guess > secret:
    print("�� 猜大了，再小一点")
else:
    print("�� 猜小了，再大一点")

print(f"\n正确答案是：{secret}")

进阶版本

可以反复猜测，直到猜对：

import random

secret = random.randint(0, 100)
attempts = 0

print("=" * 40)
print("       猜数字游戏")
print("   猜一个0-100之间的整数")
print("=" * 40)

while True:
    # 获取输入
    guess_str = input("\n你的猜测（输入q退出）：")
    
    # 允许退出
    if guess_str.lower() == 'q':
        print(f"游戏结束！正确答案是：{secret}")
        break
    
    # 转换为整数
    try:
        guess = int(guess_str)
    except ValueError:
        print("⚠️ 请输入有效的数字！")
        continue
    
    # 计数
    attempts += 1
    
    # 判断
    if guess == secret:
        print(f"\n�� 恭喜你猜对了！")
        print(f"�� 你一共猜了 {attempts} 次")
        if attempts <= 3:
            print("�� 太厉害了！")
        elif attempts <= 7:
            print("�� 表现不错！")
        else:
            print("�� 继续加油！")
        break
    elif guess > secret:
        print("�� 猜大了，再小一点")
    else:
        print("�� 猜小了，再大一点")

代码解析：

  1. random.randint(0, 100)：生成0到100之间的随机整数（包含两端）
  2. while True：无限循环，直到遇到 break 才退出
  3. try-except：处理用户输入非数字的情况
  4. guess_str.lower()：将输入转为小写，方便比较

�� 通关挑战

选择题

1. 以下哪个表达式的结果为True？

  • A. 5 > 3 and 2 > 4
  • B. 5 > 3 or 2 > 4
  • C. not 5 > 3
  • D. 5 == '5'

2. 执行 17 // 4 的结果是？

  • A. 4.25
  • B. 4
  • C. 1
  • D. 5

3. 以下代码的输出是？

x = 5
x += 3
x *= 2
print(x)

  • A. 16
  • B. 13
  • C. 11
  • D. 26

4. 哪个运算符用于判断两个值是否相等？

  • A. =
  • B. ==
  • C. ===
  • D. !=

�� 答案与解析：

点击查看答案与解析

1. 答案：B

解析过程：

  • 选项A：5 > 3 and 2 > 4
    • 5 > 3 结果为 True
    • 2 > 4 结果为 False
    • True and False = False（and要求两边都为True才为True）
  • 选项B：5 > 3 or 2 > 4
    • 5 > 3 结果为 True
    • 2 > 4 结果为 False
    • True or False = True（or只要有一个为True结果就是True）✓
  • 选项C：not 5 > 3
    • 5 > 3 结果为 True
    • not True = False
  • 选项D：5 == '5'
    • 5 是整数，'5' 是字符串
    • 虽然值看起来一样，但类型不同，Python中 == 比较时会考虑类型
    • 结果为 False

2. 答案：B

解析过程：

  • // 是整除运算符（地板除），表示取商的整数部分，向下取整
  • 17 ÷ 4 = 4.25
  • 向下取整后得到 4
  • 注意：不是四舍五入，而是直接截断小数部分取整
  • 如果是 -17 // 4，结果是 -5（向负无穷方向取整）

3. 答案：A

解析过程：

  • 初始：x = 5
  • 第一步：x += 3 等价于 x = x + 3 = 5 + 3 = 8
  • 第二步：x *= 2 等价于 x = x * 2 = 8 * 2 = 16
  • 最终输出：16

常见错误：有人可能会算成 5 + 3 * 2 = 11，这是错误的，因为赋值运算符是顺序执行的，不是一次性计算的。

4. 答案：B

解析过程：

  • 选项A：= 是赋值运算符，用于给变量赋值，如 x = 5
  • 选项B：== 是等于比较运算符，用于判断两个值是否相等，如 5 == 5 结果为 True ✓
  • 选项C：=== 是JavaScript中的严格相等运算符，Python中没有这个运算符
  • 选项D：!= 是不等于运算符，如 5 != 3 结果为 True

编程题

1. 编写程序，输入三个数字，输出其中的最大值。

�� 参考实现与解析：

点击查看代码与解析

# 方法1：使用if-else
a = float(input("输入第一个数："))
b = float(input("输入第二个数："))
c = float(input("输入第三个数："))

if a >= b and a >= c:
    max_num = a
elif b >= a and b >= c:
    max_num = b
else:
    max_num = c

print(f"最大值是：{max_num}")

# 方法2：使用内置函数（更简单）
max_num = max(a, b, c)
print(f"最大值是：{max_num}")

思路解析：

  1. 问题分析：需要比较三个数的大小，找出最大的那个
  2. 方法1的逻辑：
    • 首先比较a是否同时大于等于b和c，如果是，a就是最大值
    • 否则，比较b是否同时大于等于a和c，如果是，b就是最大值
    • 如果以上都不满足，那么c一定是最大值
  3. 方法2的逻辑：
    • Python内置的 max() 函数可以直接返回多个参数中的最大值
    • 这是更简洁、更Pythonic的写法
  4. 为什么用 >= 而不是 >：
    • 使用 >= 可以处理有相等数值的情况
    • 例如三个数都是5，用 >= 能正确返回5

2. 编写程序，输入年份，判断是否是闰年。

闰年判断规则：

  • 能被4整除但不能被100整除，或者
  • 能被400整除

�� 参考实现与解析：

点击查看代码与解析

year = int(input("输入年份："))

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year}年是闰年")
else:
    print(f"{year}年不是闰年")

思路解析：

  1. 闰年规则理解：
    • 普通闰年：能被4整除但不能被100整除（如2004、2008）
    • 世纪闰年：能被400整除（如2000是闰年，1900不是闰年）
    • 两个条件满足其一即可
  2. 代码拆解：
    • year % 4 == 0：判断能否被4整除（取余为0表示能整除）
    • year % 100 != 0：判断不能被100整除
    • year % 400 == 0：判断能否被400整除
  3. 逻辑组合：
    • (year % 4 == 0 and year % 100 != 0)：普通闰年条件
    • (year % 400 == 0)：世纪闰年条件
    • 用 or 连接两个条件，满足其一即可
  4. 测试用例建议：
    • 普通闰年：2020、2024
    • 普通平年：2021、2022
    • 世纪闰年：2000
    • 世纪平年：1900

3. 编写简易计算器，支持加减乘除。

�� 参考实现与解析：

点击查看代码与解析

num1 = float(input("输入第一个数："))
operator = input("输入运算符(+ - * /)：")
num2 = float(input("输入第二个数："))

if operator == '+':
    result = num1 + num2
elif operator == '-':
    result = num1 - num2
elif operator == '*':
    result = num1 * num2
elif operator == '/':
    if num2 == 0:
        result = "错误：除数不能为0"
    else:
        result = num1 / num2
else:
    result = "错误：未知的运算符"

print(f"结果：{result}")

思路解析：

  1. 输入处理：
    • 使用 float() 将输入转换为浮点数，支持小数运算
    • 运算符作为字符串输入，不需要转换
  2. 条件分支设计：
    • 使用 if-elif-else 结构处理四种运算符
    • 每个分支执行对应的算术运算
  3. 除零错误处理：
    • 除法运算时需要特别检查除数是否为0
    • 使用嵌套if判断 num2 == 0
    • 如果为0，返回错误提示而不是让程序崩溃
  4. 非法运算符处理：
    • 最后的 else 处理用户输入了 + - * / 以外的字符的情况
    • 提供友好的错误提示
  5. 改进建议：
    • 可以添加循环让用户能连续计算
    • 可以添加更多的运算符（如 // 整除、% 取余、** 幂运算）
    • 可以使用函数封装计算逻辑

�� 文档总结

一、核心知识点回顾

1. 数值类型（4种）

类型

关键字

特点

注意事项

整数

int

没有大小限制

除法 / 结果永远是float

浮点数

float

小数表示

精度有限，避免直接比较相等

布尔

bool

True/False

可以参与数值运算（True=1, False=0）

复数

complex

形如 3+4j

日常使用较少

类型转换要点：

  • int() 转换时截断小数部分（不是四舍五入）
  • bool() 转换时，0、空值转False，其他转True
  • 运算时Python会自动进行隐式类型转换
2. 运算符（4类）

算术运算符：

  • + - * / 基础四则运算
  • // 整除（向下取整）
  • % 取余（常用于判断奇偶、循环周期）
  • ** 幂运算

赋值运算符：

  • = 基础赋值
  • += -= *= /= //= %= 复合赋值（简化代码）

比较运算符：

  • == != > < >= <= 返回布尔值
  • 特别注意 == 和 = 的区别

逻辑运算符：

  • and：两边都为True才为True
  • or：一边为True就为True
  • not：取反

优先级口诀：括号 > 幂运算 > 乘除 > 加减 > 比较 > 逻辑

3. 条件分支（3种结构）

# 单分支
if 条件:
    语句

# 双分支
if 条件:
    语句A
else:
    语句B

# 多分支
if 条件1:
    语句1
elif 条件2:
    语句2
else:
    语句3

使用要点：

  • 条件可以是任何表达式，最终会被转换为布尔值判断
  • elif 可以有多个，else 最多一个且放在最后
  • 注意代码缩进，Python靠缩进表示代码块

二、编程思维培养

1. 程序设计的三个核心要素

数据 → 处理 → 控制
 │      │       │
变量   运算符  条件分支
类型   表达式  流程控制

2. 解决编程问题的通用步骤
  1. 理解问题：明确输入、输出、处理逻辑
  2. 分解问题：将大问题拆成小问题
  3. 设计算法：用伪代码或流程图描述解决步骤
  4. 编写代码：将算法翻译成Python代码
  5. 测试验证：用多组数据测试程序正确性
3. 猜数字游戏的程序结构分析

┌─────────────────┐
│   生成随机数     │  ← 数据准备
└────────┬────────┘
         ▼
┌─────────────────┐
│   获取用户输入   │  ← 输入处理
└────────┬────────┘
         ▼
┌─────────────────┐
│   比较大小      │  ← 核心逻辑（条件分支）
│ 猜大/猜小/猜对  │
└────────┬────────┘
         ▼
┌─────────────────┐
│   输出结果      │  ← 输出处理
└─────────────────┘

三、常见错误与避坑指南

错误类型

错误示例

正确写法

说明

赋值与比较混淆

if x = 5:

if x == 5:

= 是赋值，== 才是比较

除法结果类型

10 / 2 得 5.0

需要整数用 //

/ 永远返回float

逻辑运算符写法

if a > 5 and < 10:

if a > 5 and a < 10:

不能省略变量名

缩进错误

混用空格和Tab

统一使用4个空格

Python对缩进敏感

类型转换遗漏

input() + 5

int(input()) + 5

input返回字符串

除零错误

x / 0

先判断 if y != 0:

除法前检查除数

四、知识延伸与拓展

1. 布尔值的深层理解

# 短路求值
result = a and b  # 如果a为False，直接返回a，不计算b
result = a or b   # 如果a为True，直接返回a，不计算b

# 实际应用：设置默认值
name = user_input or "匿名"  # 如果用户没输入，使用默认值

2. 条件表达式的简洁写法

# 普通写法
if age >= 18:
    status = "成年"
else:
    status = "未成年"

# 三元表达式（简洁写法）
status = "成年" if age >= 18 else "未成年"

3. 链式比较

# 普通写法
if x >= 0 and x <= 100:
    print("在范围内")

# 链式比较（更Pythonic）
if 0 <= x <= 100:
    print("在范围内")

五、下篇预告

我们将学习 循环语句，包括：

  • for 循环：遍历序列、指定次数循环
  • while 循环：条件循环
  • 循环控制：break、continue、pass
  • 循环与条件的组合应用

掌握循环后，你将能够：

  • 批量处理数据
  • 实现更复杂的猜数字游戏（限制次数、记录历史）
  • 编写各种实用的自动化脚本

学习建议：

  1. 动手实践每一道编程题，不要只看答案
  2. 尝试修改代码，看看会发生什么
  3. 遇到错误不要慌，仔细阅读错误信息
  4. 多写注释，帮助自己理解代码逻辑
# python # java # 前端
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

别再只聊大模型！AI的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区
cover

别再只聊大模型！人工智能的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区
cover

别再只聊大模型！AI的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区