在Python中，if语句可以让你根据设定的条件来划分要执行的流程。在这里，我将解释如何在 Python 中进行条件分支。
目录
8-1 使用 if 语句来条件分支
8-2 使用缩进定义块
8-3 对象评估为 True 或 False
8-4 使用比较运算符
8-5 使用逻辑运算符
8-6 比较对象的相同性（== 运算符和 is 运算符之间的区别）
8-1 使用 if 语句来条件分支
if 语句用于 Python 中的条件分支。在这里，我将解释如何使用 if 语句进行条件分支。
if语句的基本用法
if 语句仅在指定的条件表达式为真时执行。基本格式如下。
if 条件表达式：
当条件表达式为真时执行的语句如果条件表达式为真，则依次执行其后描述的块中的语句。如果要执行多条语句，将它们写在一个块中。
if 条件表达式：
当条件表达式为真时要执行的语句1
当条件表达式为真时要执行的语句2
当条件表达式为真时要执行的语句3※ 在 Python 中，块是使用缩进定义的。有关详细信息，请参阅 “在 Python 中使用缩进定义块”。
条件表达式使用比较运算符和逻辑运算符来描述条件。以下示例在分配给变量 old 的值小于 20 时执行块中的处理。
old = 18
if old < 20:
print("20岁以下不可用")由于变量old被赋值为18，所以写在if语句中的条件表达式为真，执行后面写的块中的语句。
示例代码
请看以下两个示例。
old = 18
print("年龄是" + str(old) + "岁。")
>> 年龄是18岁。
if old < 20:
print("20岁以下禁止入内。")
print("我们期待再次见到你。")
>> 20岁以下禁止入内。
>> 我们期待再次见到你。
print("谢谢。\n")
>> 谢谢。old = 24
print("年龄是" + str(old) + "岁。")
>> 年龄是24岁。
if old < 20:
print("20岁以下禁止入内。")
print("我们期待再次见到你。")
print("谢谢。\n")
>> 谢谢。if语句在给变量old赋值后执行。在第一个示例中，if 语句的条件表达式为真，因此执行了后续块中描述的语句。在下面的示例中，if 语句的条件表达式变为 false，因此 if 语句块中的语句没有执行，而是执行了下一个过程。
条件表达式为假时的处理（if…else）
if 语句描述了块中指定条件表达式为真时要执行的处理，但您也可以描述条件表达式为假时要执行的处理。使用以下格式：
if 条件表达式：
当条件表达式为真时执行的语句
...
else:
条件表达式为假时执行的语句
...在else:之后的块中写上当if语句的条件表达式为假时要执行的语句。由于条件表达式将始终为真或假，因此将始终执行一个块中的语句，要么为真块，要么为假块。
示例代码
请看以下两个示例。
old = 18
print("年龄是" + str(old) + "岁。")
>> 年龄是18岁。
if old < 20:
print("20岁以下禁止入内。")
print("我们期待再次见到你。")
else:
print("感谢使用，请按开始键。")
>> 20岁以下禁止入内。
>> 我们期待再次见到你。old = 24
print("年龄是" + str(old) + "岁。")
>> 年龄是18岁。
print("20岁以下禁止入内。")
print("我们期待再次见到你。")
else:
print("感谢使用，请按开始键。")
>> 感谢使用，请按开始键。if语句在给变量old赋值后执行。在第一个示例中，if 语句的条件表达式为真，因此执行了后续块中描述的语句。在下面的示例中，由于 if 语句的条件表达式为假，因此执行了 else 之后的块中编写的语句。
使用多个条件表达式的条件分支（if…elif…else）
if 语句不仅可以描述单个条件表达式，还可以描述使用多个条件表达式的条件分支。使用以下格式：
if 条件表达式 1：
条件表达式 1 为真时执行的语句
...
elif条件表达式2：
条件表达式 1 为假且条件表达式 2 为真时执行的语句
...
elif条件表达式3：
条件表达式 1 和条件表达式 2 为假且条件表达式 3 为真时执行的语句
...
else:
当所有条件表达式都为假时执行的语句
...评估是从上到下进行的。首先对条件表达式1进行求值，如果为真，则执行下一个块中的语句，进行if语句的下一步处理。如果条件表达式 1 为假，则计算下一个条件表达式 2，如果为真，则执行下一个块中的语句并执行 if 语句的下一个处理。对所有条件表达式重复相同的操作，如果所有条件表达式都为假，则最后执行下一个块中的语句。
您可以根据需要编写任意数量的 elif。另外，如果不需要，可以删除 else 部分。
记述了多个条件式，但从上到下按顺序进行求值，条件式为真时，执行下一个块内的语句，移至下一个if语句。请注意，不评估条件表达式变为真之后写入的条件表达式。
这种格式与写作相同：
if 条件表达式 1：
条件表达式 1 为真时执行的语句
...
else:
if 条件表达式 2：
条件表达式 1 为假且条件表达式 2 为真时执行的语句
...
else:
if 条件表达式 3：
条件表达式 1 和条件表达式 2 为假且条件表达式 3 为真时执行的语句
...
else:
当所有条件表达式都为假时执行的语句
...※ 请注意，它是 elif，而不是其他编程语言中使用的 elseif。
示例代码
请看以下两个示例。
postcode = "126-0015"
print("邮编是" + postcode + " 。")
>> 邮编是 125-0062 。
if postcode == "126-0015":
address = "山东省青岛市市南区"
elif postcode == "102-0072":
address = "上海市浦东内环"
elif postcode == "125-0062":
address = "山东省青岛市市北区"
else:
address = "未知地址"
print("地址是 " + address + " 。")
>> 地址是山东省青岛市市南区。postcode = "125-0062"
print("邮编是 " + postcode + " 。")
>> 邮编是 102-0072 です。
if postcode == "126-0015":
address = "山东省青岛市市南区"
elif postcode == "102-0072":
address = "上海市浦东内环"
elif postcode == "125-0062":
address = "山东省青岛市市北区"
else:
address = "未知地址"
print("住所は " + address + " です。")
>> 住所是山东省青岛市市北区。分配给变量 postcode 的值由多个条件表达式计算，并执行其变为真后的块中的语句。
if语句和for语句可以设置一个条件表达式，如果条件表达式为真则执行多条语句。这个时候block表示语句要从哪里执行到哪里。块在其他编程语言中通常被定义为 { to } ，但 Python 使用缩进来表示块。在这里，我将解释如何在 Python 中使用缩进定义块。
8-2 使用缩进定义块
内部包含其他语句的语句，如 if 语句和 for 语句，称为复合语句。除了 while 和 try 语句，函数定义和类定义也是复合语句。在if语句中，当条件表达式为真时执行多条语句，用块来表示从哪里到哪里执行语句。
在Java、PHP等其他编程语言中，{to}是一个块。
if (条件表达式) {
块中处理1
块中处理2
}·Python在同一位置缩进的句子被视为同一块。如果你在不应该出现新块的地方用不同的缩进写一个句子，就会发生错误。
if 条件表达式:
块中处理1
块中处理2if 条件表达式:
块中处理1
块中处理2
块中处理3 //出现错误如果 if 语句块中还有另一个 if 语句，则进一步降低缩进。
if 条件表达式:
块中处理1
块中处理2
if 条件表达式:
块中处理1
块中处理2
if 条件式:
块中处理1
块中处理2
块中处理3
块中处理4
if 条件表达式:
块中处理1
块中处理2块仅通过缩进表示而不使用括号等，因此缩进始终整齐对齐，不会包含不必要的代码。
应该有多少缩进
缩进是用制表符或空格完成的，但是对于多少个空格没有固定的规则。如果您迷路了，有一份名为 PEP:8 的文档可作为编写 Python 代码的风格指南。
我们建议在这里每级缩进使用 4 个空格。在很多开发公司里也是统一缩进4个空格。
8-3 对象评估为 True 或 False
本节说明在 if 语句和 for 语句等条件表达式中描述对象时，哪些对象被判断为真，哪些对象被判断为假。
判断真假的标准
如果您在条件表达式（例如 if 语句）中编写使用比较运算符或逻辑运算符的表达式，它会返回布尔值 True 或 False 作为结果。（关于布尔值，参见“使用布尔值（True，False） ”）。结果决定是否执行后面的块中的语句。
作为布尔值的内置常量 True 为真，False 为假。此外，None 为假，NotImplemented 为真。
print(bool(True))
>> True
print(bool(False))
>> False
print(bool(None))
>> False
print(bool(NotImplemented))
>> True数值为 0 、 0.0 、 0j 为假，其他所有值为真。
print(bool(0))
>> False
print(bool(5))
>> True
print(bool(0.0))
>> False
print(bool(0.1))
>> True
print(bool(0j))
>> Falsestring类型的空字符串””判断为false，否则判断为true。
print(bool(""))
>> False
print(bool("Hello"))
>> True空元组 ()、空列表 [] 或空字典 {} 的计算结果为假，否则为真。
print(bool(()))
>> False
print(bool(("Blue","Red")))
>> True
print(bool([]))
>> False
print(bool(["Apple", "Orange"]))
>> True
print(bool({}))
>> False
print(bool({"A":"Apple","O":"Orage"}))
>> True我们学习了主要对象的判断为真和判断为假的内容。
示例代码
请看下面的示例。
name = "Yuhua"
if name:
print("名字是" + name + "。")
else:
print("姓名未注册。")
>> 姓名未注册。
name = "Yuhua"
if name:
print("名字是" + name + "。")
else:
print("姓名未注册。")
>> 名字是Yuhua。首先，一个空字符串被分配给变量名，然后一个非空字符串被分配，并且每个都在 if 语句的条件表达式中被评估。空字符串为假，非空字符串为真。
我们讲解了在条件表达式描述对象的时候什么样的对象被判断为真，什么样的对象被判断为假。
8-4 使用比较运算符
比较运算符用于比较两个值，比如两个值是否相等或者一个值是否大于另一个。比较运算符返回 True 或 False 作为结果。本节介绍如何使用比较运算符。
比较运算符列表
Python 提供的比较运算符列表。
x == y x 和 y 相等
X != y x 不等于 y
x > y x 大于 y
x < y x 小于 y
x >= y x 大于或等于 y
x <= y x 小于或等于 y
x in y x 存在于 y 中
x not in x 中的元素 x 在 y 中不存在比较左右两侧的对象是否相等、大于或小于等。返回布尔值 True 或 False 结果。
平等比较
相等比较使用 == 或 != 运算符。如果左侧和右侧相等，则 == 运算符返回 True。相反，如果左侧和右侧不同，则 != 运算符返回 True。
数值比较
比较数字时，可以比较整数和浮点数是否相等，而不仅仅是整数和整数。
print(bool(10 == 10))
>> True
print(bool(10 == 8))
>> False
print(bool(10 == 10.0))
>> True如果整数 10 和浮点数 10.0 在数值上相等，则比较结果为 True。
字符串比较
比较字符串时，比较字符串值是否相等。区分大小写。
print(bool("Hello" == "Hello"))
>> True
print(bool("Hello" == "Hey"))
>> False
print(bool("Hello" == "hello"))
>> False比较元组和列表
对于元组和列表，如果每个元素完全匹配则为真。
print(bool(["Red", "Blue"] == ["Red", "Blue"]))
>> True
print(bool(["Red", "Blue", "Yello"] == ["Red", "Blue"]))
>> False如果整数 10 和浮点数 10.0 在数值上相等，则比较结果为 True。
更大或更小的比较
更大或更小的比较使用 < 运算符、> 运算符、<= 运算符和 >= 运算符。如果左侧小于右侧，则 < 运算符为 True，反之则 > 运算符。此外，如果左侧小于或等于右侧，则 <= 运算符为真，而 >= 运算符反之亦然。
数值比较
比较数字时，比较数字的大小。无法通过比较复数来确定它们是大是小。
print(bool(5 > 3))
>> True
print(bool(7 < 3))
>> False
print(bool(4 >= 4))
>> True字符串比较
比较字符串时，比较字符的 Unicode 代码点。如果第一个字符相同，则将其与下一个字符进行比较。可以使用内置的 ord 函数找到字符的 Unicode 代码点。
print(ord("a"))
>> 97
print(ord("b"))
>> 98
print(ord("c"))
>> 99
print(ord("A"))
>> 65“a”的代码点是 97，“b”的代码点是 98。“A”的代码点是 65。因此，比较“a”和“b”是否较大时，“b”变大，比较“a”和“A”时，“a”变大。
print(bool("apple" > "bread"))
>> False
print(bool("apple" > "Apple"))
>> True例如，比较“abc”和“abcde”这样的字符串时，越长的字符串越大。
print(bool("abc" < "abcde"))
>> True比较元组和列表
当对元组和列表进行更大或更小的比较时，比较是在第一个不同的元素上进行的。比如比较[“red”, “blue”, “green”]和[“red”, “blue”, “white”]，第一个和第二个元素相等，所以第三个元素是比较出来的.
print(bool(["red", "blue", "green"] > ["red", "blue", "white"]))
>> False对于 [“aa”, “bb”] 和 [“aa”, “bb”, “cc”] 这样的比较，元素越多越大。
print(bool(["aa", "bb"] < ["aa", "bb", "cc"]))
>> True是否包含该元素
使用 in 运算符评估是否包含指定元素。如果包含元素，则 in 运算符为真，如果不包含元素，则 not in 运算符为真。
例如，如果“apple”在 [“orange”、“apple”、“lemon”] 列表中，则为 True。
print(bool("apple" in ["orange", "apple", "lemon"]))
>> True
print(bool("grape" in ["orange", "apple", "lemon"]))
>> False返回 True，因为“apple”在列表中，而返回 False，因为“grape”不在列表中。
关于比较不同数据类型的对象
您可能会也可能不会在 Python 中比较不同的数据类型。例如，可以比较整数和复数是否相等或大于。
print(bool (8 == 8.0))
>> True
print(bool (14 < 9.5))
>> False仅仅比较一个字符串和一个数字是否相等总是会返回 False。即使字符串是带有数值的字符串也是如此。
print(bool (10 == "10"))
>> False尝试比较字符串和数字以获得更大的值将导致 TypeError 错误。
print(bool (10 > "8"))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: '>' not supported between instances of 'int' and 'str'如果要比较数值是否大于字符串或数字，使用int函数将字符串转换为数字再进行比较。
print(bool (14 > int("10")))
>> True8-5 使用逻辑运算符
逻辑运算符（或布尔运算符）是用于组合和计算布尔值的运算符，例如 a 和 b 或 a 或 b。本节介绍如何使用逻辑运算符。
逻辑运算符列表
Python 提供的逻辑运算符列表。
x or y x或y至少有一个为True则为True
否则为False
x and y x和y都为True则为True
否则为False
not x x为True则为 alse、 x 为False则为True其实判断是True还是False时返回的是变成True或False的值，而不是True或False。稍后我会详细解释。
逻辑和
如果运算符的左侧或右侧为 True，则逻辑 OR 为 True，仅当两者均为 False 时为 False。
True or True True
True or False True
False or True True
False or False False具体用法如下。
num = 8
print(bool(num < 10 or num > 40))
>> True根据存储在变量 num 中的值计算条件表达式 num < 10 和 num > 40。在逻辑或的情况下，如果其中至少有一个为真，则整体为真，所以这次为真。
更详细一点，析取首先计算表达式 x 或 y 的 x。如果 x 为假，则返回 y。如果 x 为真，则返回 x。
逻辑積
如果运算符的左侧和右侧都为 True，则合取结果为 True，否则为 False。
True and True True
True and False False
False and True False
False and False False具体用法如下。
num = 24
print(bool(num > 10 and num < 40))
>> True根据存储在变量 num 中的值计算条件表达式 num > 10 和 num < 40。在逻辑乘积的情况下，如果两者都为真，则整体为真，所以这次为真。
更详细一点，联合案例首先计算表达式 x 和 y 的 x。如果 x 为假，则返回 x。如果 x 为真，则返回 y。
否认
如果运算符的左侧为 True，则否定为 False，如果左侧为 False，则为 True。
not True False
not False True具体用法如下。
old = 24
print(bool(not old < 20))
>> True根据存储在变量 old 中的值评估条件表达式 old < 20。在否定的情况下，如果右边为True，则结果为False，如果右边为False，则结果为True，所以这次为True。
如果表达式 not x 的 x 为假，则 Negative 返回 True。如果 x 为真，则返回 False。
8-6 比较对象的相同性（== 运算符和 is 运算符之间的区别）
使用 is 运算符检查数字、字符串、列表和元组等对象是否相同。本节解释使用 is 运算符检查对象是否相同和使用 == 运算符检查对象的值是否相同的区别。
is运算符的用法和与==运算符的区别
数字、字符串、列表和元组都是 Python 中的对象。使用 is 运算符检查对象是否相同。
x is y x 和 y 是同一个对象则为 True
x not is y x 和 y 是不同的对象则为 True一个类似的运算符是==运算符，它用来判断对象的值是否相同。如果值相同则为真，即使它们是不同的对象。另一方面，如果值相同但对象不同，则 is 运算符返回 False。
例如，请参见以下示例。创建两个列表并使用 == 和 is 运算符检查它们。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)
>> True
print(list1 is list2)
>> False首先，== 运算符测试两个列表并返回 True。这是因为对于列表，如果每个元素具有相同的数据类型和相同的值，则为真。另一方面，is 运算符返回 False。即使价值观一样，对象也不一样。
考虑以下示例。创建第一个列表后，我们将第一个列表分配给第二个列表。
list1 = [1, 2, 3]
list2 = list1
print(list1 == list2)
>> True
print(list1 is list2)
>> True在本例中，list2 和 list1 指向同一个列表对象。因此，== 不仅返回 True 来比较值，is 运算符也返回 True 来确定对象是否相同。
因此，==运算符检查对象的值是否相同，而is运算符检查对象是否相同。
mutable对象和immutable对象的 is 运算结果不一样
早些时候我尝试使用列表对象，但现在我将尝试使用字符串。
str1 = "Apple"
str2 = "Apple"
print(str1 == str2)
>> True
print(str1 is str2)
>> True不仅 == 运算符而且 is 运算符都返回 True，即使我们正在创建每个字符串对象。
有些对象一旦创建就可以更改（称为可变的），而其他对象一旦创建就不能更改（不可变的）。数字、字符串和元组是不可变对象。列表和字典是可变对象。
为什么用list创建两个相同值的对象时，它们是不同的对象，而用字符串创建两个相同值的对象时，它们就变成了同一个对象？是一样的，永远是每个对象一个不同的对象，但是在不可变对象的情况下，如果具有相同数据类型和相同值的对象已经存在，它可能会引用现有对象而无需创建新对象。
请注意，不可变对象始终被创建为单独的对象，而可变对象在创建时可能会或可能不会引用相同的对象并具有相同的值。编写假定它始终是同一个对象的代码不是一个好主意。
使用 id 函数获取对象的唯一 ID
通过使用内置函数提供的 id 函数，您可以获得一个唯一的数字，表示指定为参数的对象。例如，创建两个具有相同值的列表并使用 id 函数获取对象的 id。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1))
>> 1503216736256
print(id(list2))
>> 1503216718528这样，在列表的情况下，即使创建具有相同值的对象，也可以看到每个对象都分配了一个单独的对象。
这一次，在创建列表后，尝试将其分配给另一个列表。
list1 = [1, 2, 3]
list2 = list1
print(id(list1))
>> 1503216289728
print(id(list2))
>> 1503216289728现在这两个列表具有相同的 ID。您可以看到这两个列表引用了同一个对象。
现在让我们通过创建两个具有相同值的数字来检查。
num1 = 10
num2 = 10
print(id(num1))
>> 140706808076224
print(id(num2))
>> 140706808076224您可以看到对象具有相同的 id 并引用相同的对象，即使它们是单独创建的。这样，在数字、字符串等不可变对象的情况下，如果已经存在具有相同值的对象，则可以使用id函数引用相同的对象。
