2.python决策

    到目前为止，在你编写的程序中，语句都是逐条执行的。现在更进一步，让程序选择是否执行特定的语句块。

1. 布尔值的用武之地

    真值也称布尔值，是以在真值方面做出了巨大贡献的George Boole命名的。

    用作布尔表达式（如用作 if 语句中的条件）时，下面的值都将被解释器视为假：
False None 0 "" () [] {}

    换而言之，标准值 False 和 None 、各种类型（包括浮点数、复数等）的数值0、空序列（如空字符串、空元组和空列表）
以及空映射（如空字典）都被视为假，而其他各种值都被视为真① ，包括特殊值 True。

    这意味着任何Python值都可解释为真值。乍一看这有点令人迷惑，但也很有用。虽然可供选择的真值非常多，但标准真值为
True 和 False 。
	
	在有些语言（如C语言和2.3之前的Python版本）中，标准真值为0（表示假）和1（表示真）。实际上， True 和 False 不过
是0和1的别名，虽然看起来不同，但作用是相同的。

>>> True
True
>>> False
False
>>> True == 1
True
>>> False == 0
True
>>> True + False + 42
43

    因此，如果你看到一个返回1或0的表达式（可能是使用较旧的Python版本编写的），就知道这实际上意味着 True 或 False 。
布尔值 True 和 False 属于类型 bool ，而 bool 与 list 、 str 和 tuple 一样，可用来转换其他的值。

>>> bool('I think, therefore I am')
True
>>> bool(42)
True
>>> bool('')
False
>>> bool(0)
False
'''
鉴于任何值都可用作布尔值，因此你几乎不需要显式地进行转换（Python会自动转换）。
注意: 虽然 [] 和 "" 都为假（即 bool([]) == bool("") == False ），但它们并不相等（即 [] != "" ）。
对其他各种为假的对象来说，情况亦如此（一个更显而易见的例子是 () != False ）。
'''

2. 有条件的执行和if语句

	真值可合并，至于如何合并稍后再讲，先来看看真值可用来做什么。请尝试运行下面的脚本：

name = input('What is your name? ')
if name.endswith('Gumby'):
    print('Hello, Mr. Gumby')

	这就是 if 语句，让你能够有条件地执行代码。这意味着如果条件（ if 和冒号之间的表达式）为前面定义的真，就执行后续代码块
（这里是一条 print 语句）；如果条件为假，就不执行（你应该猜到了）。

3. else 子句

	在前一节的示例中，如果你输入以Gumby结尾的名字，方法 name.endswith 将返回 True ，导致后续代码块执行——打印问候语。
如果你愿意，可使用 else 子句增加一种选择（之所以叫子句是因为 else 不是独立的语句，而是 if 语句的一部分）。

name = input('What is your name? ')
if name.endswith('Gumby'):
    print('Hello, Mr. Gumby')
else:
    print('Hello, Stranger')

	在这里，如果没有执行第一个代码块（因为条件为假），将进入第二个代码块。这个示例表明，Python代码很容易理解，不是吗？
如果从 if 开始将代码大声朗读出来，听起来将像普通句子一样（也可能不那么普通）。

	还有一个与 if 语句很像的“亲戚”，它就是条件表达式——C语言中三目运算符的Python版本。下面的表达式使用 if 和 else 确定其值：

status = "friend" if name.endswith("Gumby") else "stranger"
print(status)

	如果条件（紧跟在 if 后面）为真，表达式的结果为提供的第一个值（这里为 "friend" ），否则为第二个值（这里为 "stranger" ）。

4. elif 子句

	要检查多个条件，可使用 elif 。 elif 是 else if 的缩写，由一个 if 子句和一个 else 子句组合而成，也就是包含条件的 else 
子句。

num = int(input('Enter a number: '))
if num > 0:
    print('The number is positive')
elif num < 0:
    print('The number is negative')
else:
    print('The number is zero')

5. 代码嵌套

	下面穿插点额外的内容。你可将 if 语句放在其他 if 语句块中，如下所示：

name = input('What is your name? ')
if name.endswith('Gumby'):
    if name.startswith('Mr.'):
        print('Hello, Mr. Gumby')
    elif name.startswith('Mrs.'):
        print('Hello, Mrs. Gumby')
    else:
        print('Hello, Gumby')
else:
    print('Hello, stranger')

	在这里，如果名字以Gumby结尾，就同时检查名字开头，这是在第一个代码块中使用一条独立的 if 语句完成的。请注意，这里还
使用了 elif 。最后一个分支（ else 子句）没有指定条件——如果没有选择其他分支，就选择最后一个分支。如果需要，这里的两个
else 子句都可省略。如果省略里面的 else 子句，将忽略并非以Mr.或Mrs.打头的名字（假设名字为Gumby）。如果省略外面的 else
子句，将忽略陌生人。

6. 更复杂的条件

	这就是你需要知道的有关 if 语句的全部知识。下面来说说条件本身，因为它们是有条件执行中最有趣的部分。

6.1 比较运算符

	从理论上说，可使用 < 和 <= 等运算符比较任意两个对象 x 和 y 的相对大小，并获得一个真值，但这种比较仅在 x 和 y 的类型
相同或相近时（如两个整数或一个整数和一个浮点数）才有意义。将整数与字符串相加毫无意义，检查一个整数是否小于一个字符串也是
一样。奇怪的是，在Python 3之前，竟然可以这样做。不过即便你使用的是较旧的Python版本，也应对这类比较敬而远之，因为结果是
不确定的，每次执行程序时都可能不同。在Python 3中，已经不允许这样比较不兼容的类型了。

	与赋值一样，Python也支持链式比较：可同时使用多个比较运算符，如 0 < age < 100 。有些比较运算符需要特别注意，如下：
1. 相等运算符：             要确定两个对象是否相等，可使用比较运算符，用两个等号（ == ）表示。

>>> "foo" == "foo"
True
>>> "foo" == "bar"
False
#两个等号？为何不像数学中那样使用一个等号呢？相信你很聪明，自己就能够明白其中的原因，但这里还是试试一个等号吧。
>>> "foo" = "foo"
SyntaxError: can't assign to literal
#一个等号是赋值运算符，用于修改值，而进行比较时你可不想这样做。

2. is - 相同运算符：

#这个运算符很有趣，其作用看似与 == 一样，但实际上并非如此。
>>> x = y = [1, 2, 3]
>>> z = [1, 2, 3]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False
'''
在前几个示例中，看不出什么问题，但最后一个示例的结果很奇怪： x 和 z 相等，但 x is z 的
结果却为 False 。为何会这样呢？因为 is 检查两个对象是否相同（而不是相等）。变量 x 和 y 指向同
一个列表，而 z 指向另一个列表（其中包含的值以及这些值的排列顺序都与前一个列表相同）。这
两个列表虽然相等，但并非同一个对象。
'''
#这好像不可理喻？请看下面的示例：
>>> x = [1, 2, 3]
>>> y = [2, 4]
>>> x is not y
True
>>> del x[2]
>>> y[1] = 1
>>> y.reverse()
'''
在这个示例中，我首先创建了两个不同的列表 x 和 y 。如你所见， x is not y （与 x is y 相反）
的结果为 True ，这一点你早已知道。接下来，我稍微修改了这两个列表，现在它们虽然相等，但
依然是两个不同的列表。
'''
>>> x == y
True
>>> x is y
False
'''
显然，这两个列表相等但不相同。
总之， == 用来检查两个对象是否相等，而 is 用来检查两个对象是否相同（是同一个对象）。
不要将 is 用于数和字符串等不可变的基本值。鉴于Python在内部处理这些对象的方式，这样做的结果是不可预测的。
'''

3. in - 成员资格运算符：

#与其他比较运算符一样，它也可用于条件表达式中。
name = input('What is your name?')
if 's' in name:
    print('Your name contains the letter "s".')
else:
    print('Your name does not contain the letter "s".')

4. 字符串和序列的比较：

#字符串是根据字符的字母排列顺序进行比较的。
>>> "alpha" < "beta"
True
#虽然基于的是字母排列顺序，但字母都是Unicode字符，它们是按码点排列的。
#其他序列的比较方式与此相同，但这些序列包含的元素可能不是字符，而是其他类型的值。
>>> [1, 2] < [2, 1]
True
#如果序列的元素为其他序列，将根据同样的规则对这些元素进行比较。
>>> [2, [1, 4]] < [2, [1, 5]]
True

6.2 布尔运算符

	至此，你已见过很多返回真值的表达式（实际上，考虑到所有值都可解释为真值，因此所有的表达式都返回真值），但你可能需要
检查多个条件。例如，假设你要编写一个程序，让它读取一个数，并检查这个数是否位于1～10（含）。为此，可像下面这样做：

number = int(input('Enter a number between 1 and 10: '))
if number <= 10:
    if number >= 1:
        print('Great!')
    else:
        print('Wrong!')
else:
    print('Wrong!')
#这可行，但有点笨拙，因为你输入了 print('Wrong!') 两次。重复劳动可不是好事，那么该如何办呢？很简单。
number = int(input('Enter a number between 1 and 10: '))
if number <= 10 and number >= 1:
    print('Great!')
else:
    print('Wrong!')
'''
运算符 and 是一个布尔运算符。它接受两个真值，并在这两个值都为真时返回真，否则返回
假。还有另外两个布尔运算符： or 和 not 。通过使用这三个运算符，能以任何方式组合真值。
'''
if ((cash > price) or customer_has_good_credit) and not out_of_stock:
	give_goods()

7. 断言

#if 语句有一个很有用的“亲戚”，其工作原理类似于下面的伪代码：
if not condition:
	crash program
'''
问题是，为何要编写类似于这样的代码呢？因为让程序在错误条件出现时立即崩溃胜过以后
再崩溃。基本上，你可要求某些条件得到满足（如核实函数参数满足要求或为初始测试和调试提
供帮助），为此可在语句中使用关键字 assert 。
'''
>>> age = 10
>>> assert 0 < age < 100
>>> age = -1
>>> assert 0 < age < 100
Traceback (most recent call last):
	File "<stdin>", line 1, in ?
AssertionError
'''
如果知道必须满足特定条件，程序才能正确地运行，可在程序中添加 assert 语句充当检查点，
这很有帮助。
还可在条件后面添加一个字符串，对断言做出说明。
'''
>>> age = -1
>>> assert 0 < age < 100, 'The age must be realistic'
Traceback (most recent call last):
	File "<stdin>", line 1, in ?
AssertionError: The age must be realistic