使用“or”在“if”语句中是一种常见但容易被忽视的技巧，它能带来更简洁的代码和更高效的逻辑表达。
你有没有想过，为什么在 Python 中，if 语句中使用 or 有时候能让你写出更简洁的代码？或者，你是否遇到过因为误用 or 导致的逻辑错误？我们今天就来聊聊这个看似简单却非常实用的逻辑运算符。
在 Python 中，or 是一个逻辑运算符，它用于连接两个表达式，并在其中任意一个为真时返回 True。但很多人可能没有意识到，or 还可以与赋值操作结合使用，这在某些场景下特别有用。
例如，你可能会看到这样的代码：
x = input("Enter a number: ")
if x == "":
x = 0
这段代码的目的是在用户输入为空时，将变量 x 设置为 0。但如果你使用 or，可以更简洁地实现同样的功能：
x = input("Enter a number: ")
if x == "":
x = 0
看起来好像没什么区别，但其实我们可以进一步简化：
x = input("Enter a number: ")
x = x or 0
这行代码的逻辑是，如果 x 是空字符串（也就是假值），那么 x or 0 会返回 0；如果 x 是非空字符串，就会返回 x。这种方式更直接，也更 Pythonic。
但你有没有想过，or 还可以用来处理多个条件？比如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，这里有一些需要注意的地方。比如，or 的短路特性。当第一个表达式为真时，后面的表达式就不会被求值。这种特性在某些情况下很有用，但在其他情况下可能会带来问题。
举个例子，假设你有两个变量 a 和 b，你想在 a 为 None 的时候使用 b 的值。你可以这样写：
a = None
b = 10
result = a or b
这行代码会返回 b，因为 a 是 None，也就是假值。但如果你写成：
a = 5
b = 10
result = a or b
这会返回 a，因为 a 是真值。这种行为是 or 的短路特性的体现。
但你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
不过，你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
但你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 ZeroDivisionError。为什么会这样？因为 or 在求值第一个表达式时，如果它为假，才会继续求值第二个表达式。但在这里，c 的求值会抛出异常，而不管 a 是否为零。
那么，如何避免这种情况？你可以使用 or 的另一种形式，即 or 的短路特性。例如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在 c 的求值过程中会抛出异常，所以你不能依赖 or 来避免这种情况。你需要使用 try-except 块来捕获异常。
但你有没有想过，or 还有一种更高级的用法？比如，你可以使用 or 来处理多个条件，而不仅仅是两个。例如：
if a or b or c:
# do something
这行代码的意思是，只要 a、b 或 c 中有一个为真，就会执行 if 块中的代码。这在处理多个可选参数时特别有用。
不过，你有没有遇到过这样的情况：你希望在多个条件中使用 or，但其中一个条件的求值可能会引发异常？比如：
a = 0
b = 10
c = 1 / a
result = c or b
这段代码在执行 c 的时候会抛出一个 `