第四章-选择与循环结构

王兆威

已于 2023-05-29 11:58:26 修改

阅读量295

点赞数

分类专栏： Python学习之路文章标签： python 开发语言

于 2023-05-29 11:57:58 首次发布

本文链接：https://blog.csdn.net/weixin_55577641/article/details/130925463

版权

Python学习之路专栏收录该内容

14 篇文章 0 订阅

订阅专栏

第四章 - 选择与循环结构

4.1 条件选择

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

4.1.1 if语句

if condition_1:
    statement_block_1

a = 80

if a > 60:
    print('合格')

4.1.2 if - else

这种语句是一种常用的if-else语句，通常用于二分支结构的条件语句代码。

if condition_1:
    statement_block_1
else:
    statement_block_2

a =70

if a < 60:
    print('不及格')
else:
    print('及格')

4.1.3 if - elif - else

在一些时候，我们可能需要多分支的条件语句代码，可以在if-else语句中混合elif语句进行使用：

Python 中用 elif 代替了else if，所以if语句的关键字为：if – elif – else。

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句，
如果 “condition_1” 为 False，将判断 “condition_2”，
如果"condition_2" 为 True 将执行 “statement_block_2” 块语句，
如果 “condition_2” 为 False，将执行"statement_block_3"块语句。

a = 80

if a > 90:
    print("优秀")
elif a > 60:
    print("良好")
else:
    print("不及格")

注意：

每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
在 Python 中没有 switch – case 语句，但在python3.10中添加了用法类似的match-case语句。

4.1.4 match-case语句（python3.10新特性）

在其他语言（比如说经典的C语言）中有一种多分支条件判断语句，可以进行模式匹配（通俗的讲，就是将传入的内容跟多个已存在的样例进行比较，找到相同的案例并按照该案例的代码进行处理，如果没有相同案例就按默认案例进行处理，可以查看其他编程语言的条件语句的Switch相关部分内容进行比较参考）。在python3.10中也引入了这样的新特性。

match-case语句的结构一般如下所示：

match variable: #这里的variable是需要判断的内容
    case ["quit"]: 
        statement_block_1 # 对应案例的执行代码，当variable="quit"时执行statement_block_1
    case ["go", direction]: 
        statement_block_2
    case ["drop", *objects]: 
        statement_block_3
    ... # 其他的case语句
    case _: #如果上面的case语句没有命中，则执行这个代码块，类似于Switch的default
        statement_block_default

一个match语句的使用示例：

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the Internet"

上述代码等价于：

    def http_error(status):
        if status == 400:
            return "Bad request"
        elif status == 404:
            return "Not found"
        elif status == 418:
            return "I'm a teapot"
        else:
            return "Something's wrong with the Internet"

4.1.5 if 操作运算符

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较对象是否相等
!=	不等于

只要返回结果为布尔型（true或者false）的，都可以作为if的条件，所以在之前的集合等内容中涉及到的判断元素是否在集合中的in和not in，都可以作为if的条件。

lst1 = ['张三','李四','王五']

a = '李四'

if a in lst1:
    print("在列表中")

if a not in lst1:
    print("不在列表中")

4.1.6 实例

# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("猜数字!")

while guess != number:
    guess = int(input("请输入你要猜的数字"))
    if guess == number:
        print("你猜中了，真厉害！")
    elif guess < number:
        print("猜小了，再猜猜？")
    elif guess > number:
        print("猜大了，在猜猜？")

4.1.7 嵌套 if

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

4.2 循环结构

Python 中的循环语句有 for 和 while。

Python 循环语句的控制结构图如下所示：

4.2.1 while 循环

while 判断条件(condition)：
    执行语句(statements)……

同样需要注意冒号和缩进。另外，在 Python 中没有 do…while 循环。

# 计算 1 - 100 的总和
sum = 0
conter = 1

while conter <= 100:
    sum += conter
    conter += 1

print("1到 100的和为：%d"%(sum))

无限循环

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)
 
print ("Good bye!")

你可以使用 CTRL+C 来退出当前的无限循环。

无限循环在服务器上客户端的实时请求非常有用。

4.2.2 while循环使用else语句

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

语法格式如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

expr 条件语句为 true 则执行 statement(s) 语句块，
如果为 false，则执行 additional_statement(s)。

# 循环输出数字，并判断大小：
count = 0

while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

简单语句组

类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中，如下所示：

flag = 1
 
while (flag): print ('欢迎访问!')
 
print ("Good bye!")

4.2.3 for 语句

Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

names = ["张三", "李四","王五","不知道起个啥"]

for name in names:
    print(name)

打印字符串中的每个字符

word = 'zhangsan'
 
for letter in word:
    print(letter)

4.2.4 for - else

在 Python 中，for…else 语句用于在循环结束后执行一段代码。

语法格式如下：

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

for x in range(6):
  print(x)
else:
  print("Finally finished!")

4.2.5 for 与 range 的使用

Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。

Python3 list() 函数是对象迭代器，可以把 range() 返回的可迭代对象转为一个列表，返回的变量类型为列表。

range(stop)
range(start, stop[, step])

参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如 range(5) 等价于 range(0， 5)
stop: 计数到 stop 结束，但不包括 stop。例如：range(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
step：步长，默认为 1。例如：range(0， 5) 等价于 range(0, 5, 1)

for num in range(1,6):
    print(num)

1、只有一个参数

如果只提供一个参数，它将生成一个从 0 开始的整数序列，参数为结束值，步长默认为 1：

for num in range(10):
    print(num)

2、加步长

可以指定步长，以便每次增加不同的数量：

for num in range(1,6,2):
    print(num)

注意：结束值 6 不包括在内。

另外，我们可以使用负数作为步长，以便从结束值倒序生成序列：

for number in range(6, 1, -1):
    print(number)

注意：如果使用负数作为步长，则开始值必须大于结束值。

3、range生成一个迭代对象

如果您只需要生成一个整数序列，并不需要使用 for 循环遍历它，那么您可以将 range() 函数的返回值转换为列表或元组.

以下生成一个整数列表：

numbers = list(range(1, 6))
print(numbers)
# [1, 2, 3, 4, 5]

以下生成一个整数元组：

numbers = tuple(range(1, 6))
print(numbers)
# (1, 2, 3, 4, 5)

4.2.6 break 和 continue 语句

1、break

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

for letter in 'Runoob':     # 第一个实例
   if letter == 'b':
      break
   print ('当前字母为 :', letter)
  
var = 10                    # 第二个实例
while var > 0:              
   print ('当前变量值为 :', var)
   var = var -1
   if var == 5:
      break
 
print ("Good bye!")

2、continue

continue 语句被用来告诉 Python 跳过当前循环中的当此循环，然后继续进行下一轮循环。

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)
 
var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")

3、else

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

如下实例用于查询质数的循环例子:

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')

4、pass语句

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

while True:
    pass  # 等待键盘中断 (Ctrl+C)

4.2.7 实例

1、九九乘法表

for i in range(1,9):
    for j in range(1,i+1):
        print("%d*%d=%d"%(i,j,i*j),end="\t")
    print()

2、计算阶乘

整数的阶乘（英语：factorial）是所有小于及等于该数的正整数的积，0的阶乘为1。即：n!=1×2×3×…×n。

# 通过用户输入数字计算阶乘

# 获取用户输入的数字
num = int(input("请输入一个数字: "))
factorial = 1

# 查看数字是负数，0 或 正数
if num < 0:
   print("抱歉，负数没有阶乘")
elif num == 0:
   print("0 的阶乘为 1")
else:
   for i in range(1,num + 1):
       factorial = factorial*i
   print("%d 的阶乘为 %d" %(num,factorial))

3、Python 斐波那契数列

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。

# Python 斐波那契数列实现

# 获取用户输入数据
nterms = int(input("你需要几项？"))

# 第一和第二项
n1 = 0
n2 = 1
count = 2

# 判断输入的值是否合法
if nterms <= 0:
   print("请输入一个正整数。")
elif nterms == 1:
   print("斐波那契数列：")
   print(n1)
else:
   print("斐波那契数列：")
   print(n1,",",n2,end=" , ")
   while count < nterms:
       nth = n1 + n2
       print(nth,end=" , ")
       # 更新值
       n1 = n2
       n2 = nth
       count += 1

4、Python 阿姆斯特朗数

如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数。例如1^3 + 5^3 + 3^3 = 153。

1000以内的阿姆斯特朗数： 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407。

# Python 检测用户输入的数字是否为阿姆斯特朗数

# 获取用户输入的数字
num = int(input("请输入一个数字: "))

# 初始化变量 sum
sum = 0
# 指数
n = len(str(num))

# 检测
temp = num
while temp > 0:
   digit = temp % 10
   sum += digit ** n
   temp //= 10

# 输出结果
if num == sum:
   print(num,"是阿姆斯特朗数")
else:
   print(num,"不是阿姆斯特朗数")

5、Python 简单计算器实现

以下代码用于实现简单计算器实现，包括两个数基本的加减乘除运输：

# 定义函数
def add(x, y):
   """相加"""

   return x + y

def subtract(x, y):
   """相减"""

   return x - y

def multiply(x, y):
   """相乘"""

   return x * y

def divide(x, y):
   """相除"""

   return x / y

# 用户输入
print("选择运算：")
print("1、相加")
print("2、相减")
print("3、相乘")
print("4、相除")

choice = input("输入你的选择(1/2/3/4):")

num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))

if choice == '1':
   print(num1,"+",num2,"=", add(num1,num2))

elif choice == '2':
   print(num1,"-",num2,"=", subtract(num1,num2))

elif choice == '3':
   print(num1,"*",num2,"=", multiply(num1,num2))

elif choice == '4':
   print(num1,"/",num2,"=", divide(num1,num2))
else:
   print("非法输入")

以下部分更改到函数章节


<br>

>> ## 4.3 迭代器与生成器

<br>

### **4.3.1 迭代器**

<br>

***1、可迭代对象与迭代器***

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

可迭代对象：字符串、列表、元组、字典、集合、range对象都可用于创建迭代器：

```py
lst = [1,2,3,4]

# 可迭代对象可以使用for循环来挨个读取元素
for i in lst:
  print(i)

可迭代协议

字符串、列表、元组、字典、集合为可迭代对象，他们为什么为可迭代的呢？需要满足什么要求呢？

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了 __iter__() 方法。

2、判断一个对象是否是可迭代对象

我们知道可迭代对象包含__iter__ 方法，那我们可以判断这个方法有没有在对象的内部存在。

lst = [1,2,3,4]

print('__iter__' in dir(lst))

还有我们可以使用 isinstance() 来判断这个对象类型是不是迭代类型。

Iterable：可迭代的

Iterator：迭代器

from collections import Iterable
from collections import Iterator

# 字符串是可迭代对象，但是不是迭代器
print(isinstance('zhangsan',Iterable))
# True  
print(isinstance('lisi',Iterator))
# False

注意： 因为字符串、列表、元组、字典、集合为可迭代对象，并不是迭代器，所以不能使用 next()

3、迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

一个对象的内容部含有 __iter__() 方法，就是可迭代对象，可迭代对象满足可迭代协议。

通过iter() 与 __iter__()方法创建会返回一个迭代器对象。

list=[1,2,3,4]

it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素
# 1

print (next(it))
# 2

4、创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。Python3 面向对象

__iter__() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

执行输出结果为：

5、遍历迭代器

迭代器对象可以使用常规for语句进行遍历：

list=[1,2,3,4]

it = iter(list)    # 创建迭代器对象
# it = list.__iter__() # 转化成迭代器

for x in it:
    print (x, end=" ")

执行以上程序，输出结果如下：

1 2 3 4

也可以使用 next() 函数：

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
# it = iter(list)    # 创建迭代器对象
it = list.__iter__()  # 转换成可迭代对象
 
while True:
    try:
        print (next(it))
        # print(it.__next__())
    except StopIteration: # 当next超过值时会报错
        sys.exit()

执行以上程序，输出结果如下：

6、可迭代对象与迭代器区别

区别：

可迭代对象不能取值，迭代器是可以取值的
迭代器非常节省内存
迭代器每次只会取一个值
迭代器是单向的，不反复

可迭代对象如何转换为迭代器

# 创建一个可迭代对象
lst = [1,2,3,4,5]

# 转换成迭代器，使用__iter__()
itel = lst.__iter__()

print(itel)  
# <list_iterator object at 0x7f9728064e10>

# 或者可以使用iter()
itel2 = iter(lst)
print(itel2)  
# <list_iterator object at 0x7f8836b3ee10>

# 变成迭代器之后可以使用__next__(),挨个取值
print(itel.__next__())  # 1
print(itel.__next__())  # 2
print(itel.__next__())  # 3
print(itel.__next__())  # 4
print(itel.__next__())  # 5

# 当next的值已经结束到最后一个值的时候，再次next则会报错
print(itel.__next__())  # StopIteration

5、StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

执行输出结果为：

4.3.2 生成器

1、生成器

迭代器有两种：一种是调用方法直接返回的，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。

如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。

Python中提供的生成器：

生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

生成器Generator：

本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)
特点：惰性运算,开发者自定义
在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

1、创建生成器函数

生成器创建可以通过生成器函数，以及生成器表达式来创建。

一个包含 yield 关键字的函数就是一个生成器函数。yield 可以为我们从函数中返回值。

l1 = [1, 2, 3]
iter1 = iter(l1)


def func1(x):
    x += 1
    yield x
    print(222)
    yield 'alex'


g_obj = func1(5)  # 生成器函数对象
print(g_obj)  # <generator object func1 at 0x000001943DFE4350>

# 一个next 对应一个yield
# yield将值返回给 生成器对象.__next__()
print(g_obj.__next__())
print(g_obj.__next__())

这里说一下yield与return的区别：

return 结束函数，给函数的执行者返回值，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。

yield 不会结束函数，一个next对应一个yield，给生成器对象.__next__()返回值

以下实例使用 yield 实现斐波那契数列：

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

生成器监听文件输入的例子

import time


def tail(filename):
    f = open(filename)
    f.seek(0, 2) #从文件末尾算起
    while True:
        line = f.readline()  # 读取文件中新的文本行
        if not line:
            time.sleep(0.1)
            continue
        yield line

tail_g = tail('tmp')
for line in tail_g:
    print(line)

send用法

send 获取下一个值的效果和next基本一致,只是在获取下一个值的时候，给上一yield的位置传递一个数据。

使用send的注意事项：

第一次使用生成器的时候，是用next获取下一个值
最后一个yield不能接受外部的值

def generator():
    print(123)
    content = yield 1
    print('=======',content)
    print(456)
    yield2

g = generator()

ret = g.__next__()
print('***',ret)

ret = g.send('hello')   #send的效果和next一样
print('***',ret)

计算移动平均值

def averager():
    total = 0.0
    count = 0
    average = None
    while True:
        term = yield average
        total += term
        count += 1
        average = total/count


g_avg = averager()
next(g_avg)
print(g_avg.send(10))
print(g_avg.send(30))
print(g_avg.send(5))

yield from

yield是每次“惰性返回”一个值，其实从名字中就能看出，yield from 是yield的升级改进版本，如果将yield理解成“返回”，那么yield from就是“从什么（生成器）里面返回”，这就构成了yield from的一般语法，即

yield from generator

这样的形式。我们通过一个简单例子来看

def gen1():
    for c in 'AB':
        yield c
    for i in range(3):
        yield i

print(list(gen1()))

def gen2():
    yield from 'AB'
    yield from range(3)

print(list(gen2()))

yield from 后面可以跟的可以是“ 生成器、元组、列表、range（）函数产生的序列等可迭代对象”

简单地说，yield from generator 。实际上就是返回另外一个生成器。而yield只是返回一个元素。从这个层面来说，有下面的等价关系：yield from iterable本质上等于 for item in iterable: yield item 。

更多高级用法可以参考 https://blog.csdn.net/qq_27825451/article/details/85244237
ontent)
print(456)
yield2

g = generator()

ret = g.next()
print(‘***’,ret)

ret = g.send(‘hello’) #send的效果和next一样
print(‘***’,ret)


计算移动平均值

def averager():
total = 0.0
count = 0
average = None
while True:
term = yield average
total += term
count += 1
average = total/count

g_avg = averager()
next(g_avg)
print(g_avg.send(10))
print(g_avg.send(30))
print(g_avg.send(5))


**yield from**

yield是每次“惰性返回”一个值，其实从名字中就能看出，yield from 是yield的升级改进版本，如果将yield理解成“返回”，那么yield from就是“从什么（生成器）里面返回”，这就构成了yield from的一般语法，即

```py
yield from generator

这样的形式。我们通过一个简单例子来看

def gen1():
    for c in 'AB':
        yield c
    for i in range(3):
        yield i

print(list(gen1()))

def gen2():
    yield from 'AB'
    yield from range(3)

print(list(gen2()))

yield from 后面可以跟的可以是“ 生成器、元组、列表、range（）函数产生的序列等可迭代对象”

更多高级用法可以参考 https://blog.csdn.net/qq_27825451/article/details/85244237
`

王兆威

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
第四章-选择与循环结构

这种语句是一种常用的if-else语句，通常用于二分支结构的条件语句代码。在一些时候，我们可能需要多分支的条件语句代码，可以在if-else语句中混合elif语句进行使用：Python 中用 elif 代替了else if，所以if语句的关键字为：if – elif – else。如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句，如果 “condition_1” 为 False，将判断 “condition_2”，
复制链接

扫一扫