9.python的布尔类型与流程控制

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

布尔类型其实可以算是一种特殊的数字，下面是 help() 函数得到的帮助信息：

Help on class bool in module __builtin__:class bool(int)
| bool(x) -> bool
|
| Returns True when the argument x is true, False otherwise.
| The builtins True and False are the only two instances of the class bool.
| The class bool is a subclass of the class int, and cannot be subclassed.
|
| Method resolution order:
| bool
| int
| object
|
| Methods defined here:
|
| __and__(...)
| x.__and__(y) <==> x&y
|
| __or__(...)
| x.__or__(y) <==> x|y
|
| __rand__(...)
| x.__rand__(y) <==> y&x
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __ror__(...)
| x.__ror__(y) <==> y|x
|
| __rxor__(...)
| x.__rxor__(y) <==> y^x
|
| __str__(...)
| x.__str__() <==> str(x)
|
| __xor__(...)
| x.__xor__(y) <==> x^y
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| ----------------------------------------------------------------------
| Methods inherited from int:
|
| __abs__(...)
| x.__abs__() <==> abs(x)
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __cmp__(...)
| x.__cmp__(y) <==> cmp(x,y)
|
| __coerce__(...)
| x.__coerce__(y) <==> coerce(x, y)
|
| __div__(...)
| x.__div__(y) <==> x/y
|
| __divmod__(...)
| x.__divmod__(y) <==> divmod(x, y)
|
| __float__(...)
| x.__float__() <==> float(x)
|
| __floordiv__(...)
| x.__floordiv__(y) <==> x//y
|
| __format__(...)
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getnewargs__(...)
|
| __hash__(...)
| x.__hash__() <==> hash(x)
|
| __hex__(...)
| x.__hex__() <==> hex(x)
|
| __index__(...)
| x[y:z] <==> x[y.__index__():z.__index__()]
|
| __int__(...)
| x.__int__() <==> int(x)
|
| __invert__(...)
| x.__invert__() <==> ~x
|
| __long__(...)
| x.__long__() <==> long(x)
|
| __lshift__(...)
| x.__lshift__(y) <==> x<<y
|
| __mod__(...)
| x.__mod__(y) <==> x%y
|
| __mul__(...)
| x.__mul__(y) <==> x*y
|
| __neg__(...)
| x.__neg__() <==> -x
|
| __nonzero__(...)
| x.__nonzero__() <==> x != 0
|
| __oct__(...)
| x.__oct__() <==> oct(x)
|
| __pos__(...)
| x.__pos__() <==> +x
|
| __pow__(...)
| x.__pow__(y[, z]) <==> pow(x, y[, z])
|
| __radd__(...)
| x.__radd__(y) <==> y+x
|
| __rdiv__(...)
| x.__rdiv__(y) <==> y/x
|
| __rdivmod__(...)
| x.__rdivmod__(y) <==> divmod(y, x)
|
| __rfloordiv__(...)
| x.__rfloordiv__(y) <==> y//x
|
| __rlshift__(...)
| x.__rlshift__(y) <==> y<<x
|
| __rmod__(...)
| x.__rmod__(y) <==> y%x
|
| __rmul__(...)
| x.__rmul__(y) <==> y*x
|
| __rpow__(...)
| y.__rpow__(x[, z]) <==> pow(x, y[, z])
|
| __rrshift__(...)
| x.__rrshift__(y) <==> y>>x
|
| __rshift__(...)
| x.__rshift__(y) <==> x>>y
|
| __rsub__(...)
| x.__rsub__(y) <==> y-x
|
| __rtruediv__(...)
| x.__rtruediv__(y) <==> y/x
|
| __sub__(...)
| x.__sub__(y) <==> x-y
|
| __truediv__(...)
| x.__truediv__(y) <==> x/y
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| bit_length(...)
| int.bit_length() -> int
|
| Number of bits necessary to represent self in binary.
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number

bool

首先，请注意这一行：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAH4AAAAWCAIAAACJ5r/oAAAC0ElEQVRoge1YTUvjUBTNauYvuBrmH+islaKIUqS1YulsrCCKq3YW8wNaSruztgtF3CkVTHFZFF0ruuhKdIpGGCgIk1Ipiigtc+97L7MIOJK8fLRJRmnm0EVzct+5J4eXm7SC8h9vBOGtDfgXfo+edTqsXqfVKq1UsFymlQqtVlm9zjodr1v7NHq6v4/pNExMQCAAsRgmk5jLoShiLofJJMRiEAjA5CSmUvTgwCMP/oqeyTJZW4NAALNZKkns4cGs+P6eXl1hJgOjo2R9nTUa7prxUfS4sgKRCNnZYe12VwvZ8zMplSAcJvm8i378Ej0uLNCzM4ci9PQUFxdd8aP4JHoIhWit5ooUvbyESMQVqT6PnrXbEA6zZtNNTVn+PTvb7dTSo8+jJ/k82dtTFEVw6UJVHdzdJYWCUynLTurHUzhvYeQTwmHWaOh5J+0EQWGy7Hzs2LLgdfRutdCIsOtrmJ93Is5dqJIQjzNJ6lFX1enZgbvwInosl1EUHW5wIx5FEcvl3qU10b/ctpqW3BuWW6bnjTSNBI00LUm9TyZJEI9brn05fM2/9sNtBHNz7ObG7JKs8FdV40bTyejwtVebJN+HG5qcWT89/emDbN5O0YVu6fnzx18wM8M/Zxv86LVFBiPPaPvoy6x9eBM9WV39NsAZC3Y2E1dQxfeBEikW+edso8fouUGY6Fim71H0rNO5GYwwWbvxnUTPbm9/DH51/tdmnw8cFT+/ROjFhUmlZfQvX+j5uTQ0y2/TJfiPWT1jyTt5xppU2iQtn4q4tERPTsydmyiroMfHuLxsZ37agfevje8DgqCQQgFCIbK9zZ6eulrLHh/J1hZMTWGx6Fbuin+iV8GaTbKxAWNjmE7TWo21WmbFrRat1TCVgvFxsrnJ7u7cNfNeflL9Y9DDQ8xkIBiEkRGIRjGRwGwWRRGzWUwkIBqF4WEIBjGToUdHHnn4A05KXWYKuwzVAAAAAElFTkSuQmCC" alt="" />

其父类为 int 而且其内置方法也是一模一样，也就是说布尔类型也是可以和整型一样进行各种运算的，但一般没有人那么做。

布尔类型只有两个值： True 和 False ，或者说只返回两个值。

注意：python是严格区分大小写的，别写错了。

一般布尔值是用于流程控制的，下面我们来讲讲python中的流程控制是怎么样的。

但是，在这之前，我们要先了解python的缩进和编程风格。

首先，python代码的执行是从上往下逐一解释的，而如果大家开头都是对齐的话：

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAdcAAAB7CAIAAACpT123AAAMyklEQVR4nO3dTZLrqhmAYVaSDLMFNmR2EfcKwsyjuwRPwywDb+J2pa5WkN4EGUggxI9AsmTsc96nurq61RII3HzGyNYnLACgH9H7BADgt0YUBoCeiMIA0BNRGAB6IgoDQE9EYQDoiSgMAD3lo7BRyvhfBi3FZNpqlIi2AAB2SaLwFGF9dB30RQ/zn9S/rVHSbRm0JA4DwBOyc2Gj5tha+jm/AQCwSTUKzwYt/SR4mjMTggHgOa1ReBmCV3YEAGzQFIWNEpkQnNsTALBJPQoPWgaX6vTi6lw5PAMAWpTeI+HfJxH8LsQUc+dtTIQB4Cl8agMAeiIKA0BPRGEA6IkoDAA9EYUBoCeiMAD0RBQGgJ6IwgDQE1EYAHoiCgNAT0RhAOjp3IxHZE4CgHWnZTwicxIANDg14xGZkwCg4tSMR2ROAoCKUzMekTkJACpOzXhE5iQAqDg14xGZkwCg4rSMR2ROAoAGfGoDAHoiCgNAT0RhAOiJKAwAPRGFAaAnojAA9EQUBoCeiMIA0BNRGAB6+sWi8PC46J/eJ/F74yEAtnlZFDZ3Ia5CfW887FttOOpbycdvfzeKHy2/ll2dbmk5ar9B3/hEOtAsjsLfSnyJ6et68Fgy9z2DvPkoBv8s7bSWbtz3AGXwdAi0i6PwQxs/Gr/1sS8tz43C30rcjwjCP1ofEom61v7SKJw5Z6OOfgoHflnJXNjYeTQac2g8OjUKHzWPO2w+2LX2V0bh7FHRxr69Cry1/P2F5zFj1LRcOOhbsG44LiN+iWD6OehbtI4xHeJfnJq7UHclvoS4uZsJN5TjJuaVBeL5nH+0vAp5k+IqL3c515Wcz7z8cpX6xzV22pKtq9Abacm13phWyR9azr1Rrb1QcqYPD4rCacnNPUbYBVrVovD0qxt18Q7+h+Ehx7EabnERZzrW3MfxPOjbvKVajo/C66M6PGdzF/Ix+O/L88nUvtL2bEVRb6Qtbe2Nmx6SM1+vvdg/tXJ2ROH1KtZLJgoDrRqjcDKi3CToWhyf5h7PknKDubmcWy0XR3BFaCwk/F6ofZqThpeSWqJwe0s39sae2tM+LJ3A9hWJfMkNPcaVUqDZvijstgz6Fs9h/bUaP/uzdhjc7K8wG10rZ9rnR18ql92NcpE6G4Uzc+HHYv9l04pr4mlvpC1t7I1yFC7WXuyfoA+zJ/nEXHguubXHfrQ85Eop8DtIo/DwkPmFv8VsdFwhlZe7jPeM1mHDFd6HNmPh8xCtlTMuRN7NuNpbiSPjdHhczbwr5b9PpxSv3k4tXb4nzzU/O5Ur9Ua6ClzpjWlqfFVmXmuu1l4qedmH/3WLuX6fn2RLKr/PsuT/NfZYZiLMAgVQxGfncCweAmCbXywKA8CHIQoDQE9EYQDoiSgMAD0RhQGgJ6IwAPREFAaAnojCANDTG0bh8cO+wUd+AezEaPoAB0bhxadU92fQGT//+tztYLS0L7uZTKUuY4WwUhf/Pui1v7bv00VjPw+60glbHdsh5/23vPL/MG/7aCqM3F/jvtuNhocsxq4jc4M5e6JwIStS+tHVPX03JviI0nyMw3j8qv43DdoKNYU/oawdrGw7cIepLmuttUblh1xpu/9r7W5xTfu8Xtj2qvVO2OrADtnUijcpuV12NDXI3bLq+Q+mB7dh2Xizp2dqN/c9/3nrsase2Wp34l3YNxcOblS21jsHPYOZ+b9Zy1owHax0AVfLaaz6Hw4W1GWtVYXp3lm1R8yuWvYdZeO2V72oE1ZkWxq14sA+PK/kVzhj7uluqWitNerYueRqpfsqejYKb6r6mShs7kJ9r2VFOuaxDCPvYKz/t1S5KBC+BvQ7ZPd8XljXOPFRubnPSbUfUsvuc9v6Wvs1nbD1BKJWHNiH55X8EmdE4XBt2uc6ONXwkLtb8XwUtu3N3B2Flzf/XtyeMdxtuSXNDFQ1WClt4+6L14D+wKAELd3Kht/NzAsd07qHtMb9UDwqeb05zvVUcKrTYujFSmn/UFMJ8mKlsC7D0aKWaeVE2ou0orRP7nyMmpdrhLT/KbTC77YoWSzLb+iNRdsHK4W9XKwQVut8Of6xkEHtWloRbCnWFZUTnFVwl/lkqcptGeNgvqXJatJ6b8zrWu5hGnqUHIr60JcT9ufemfRy5MajO5evy7aM7iRuNJ1LW+2JMBF4exY0dzdXeVsmWltmXGuObG0r8k/PheON6W7zGSVZf1qqal5ci+K1PzD9ITxEWRte7UkvpmVPIKrL/TpPXsw0BuZFauU2muVzQFi4cSNqfZ/0fHLlRK2YG1gq2bXCqHJvJG0fn3iUCl6mFHrVNGxZ1JWeT3raaV1+KWClpUkr8r2RlqySC4OvLDmS68NpyA/28tTVy+pYTvN1NYxuo1yCAllNnbN6PtlsYdVDWrKgBVs25MRZaXvTrPnJdeH1jZm++9r4ZBj9a5ry80q08ugPDEuY5ghq+auYx3/24nt0VFpXOHNxN5RfFJh+z7audM7RKaXnUyonpJYtbak9W07Udi2t1nGxpV5t+WG9N9LOaXwEo43pOnVai0h6LH4+eG3JpUaFe45PivqyexY8nU7DWE6D1Pro3pTZa/181hMhrtRYzYLW8kP2fJ7KgfvKKJxm/WmpqunSXPov6y/KK/8a3B3s1+zmC/fD/LI9egGRHpXWpYJXmr5kqad5mTJTseH36CSjX9f2Sc5n3mewZsgcEu4gRfEo3y4VrFpE5WT7WajFQ7PSqz5CZR6dcl1+n7RDsnX5iWGQMyTf0mwXxX3oSh60VcYOOncy55ecSvvQuglBeaLZvKC5OQpXR7e5+7dGZGaam86nMQqne1azoLkt8/VDn9BLlVcksm0/9+rcMiXSVGP8HpR8Bp00M1CDaEFztJhxZNeOTTzdyCzvuqU0Ie1fJjNDyRyV1KWDZVzlz9NMxV6kFf+wQlilrXTfpZ5Pz1c3VaTmP/3rj8wpZRep/fJxqRX+fLSal1DzC9NjmM6Wk+vnQVtjrY5WEpYLmlpPdYWtkHK1ruh8AougnNQ1b8n1T3SdIFTqDSHtX24Rdggf4leWnJtiL/pwrmx9HaO+GJgZufHoLuTrqo5uv4PYcpmusfaVJivTnAVtqu6q1N01ZHqDsNvSGNle8E6196LWnvw/uK53c2Db1e4LR+aZi07WnvkIvvh/I9uHq2/lfLdP0L3b+XTz7lF4vlLMF198bfzCR+CBAoCeiMIA0BNRGAB6IgoDQE9EYQDoiSgMAD0RhQGgJ6IwAPTUPQofeCfTtTwlAPCeukfhIzKpzPpmxwKAzbpH4SY/WrfFVqIwgA/zEVG4PbYShQF8mLOi8Jgg5K7c/d/8PeimW8lNt+z8quYyCe5rt7bmu8xTAgCf4ry5sLup83wHZXOP7ko8bazmMqnOcNM8JQDwGU6NwispQ9LdSkeVDlyvCwA+w6lROMom8nQUNqYQYdM8JQDwGc6Nwjfp8pQEy7u3IKnLV1MuE5djaSVPUpKnBAA+wgtWJAAARSe+R+Ircy0OALDwEe8XBoBfFlEYAHoiCgNAT0RhAOiJKAwAPRGFAaAnojAA9EQU3qrl0yh8YgVAK6LwVuae/yhKmG+ptE9SVOdg3ZAjatC3+SPm9olzJh8VkBdH4fG+wN/+1g17P/w2fnbuS9Tu//Bh3G2D8sxdqD8r+yxLOzLb0z7rUXV4SH+LD3dPj/3n3P1ZB3hH6VzY3Rf42TEzH/6tu8ea13ijKHNQjqhjW/RG/QO8j2wUVndjDorCJw289xzP73NWR+WIIgoDp8tH4W+jH8M8Zn609Pef/NHyKuRNiqu83GVwm8oplZF/Me5uUxklN3IZj/7M5kCKyintU5HLnLSzFW125FuKsz1ZGyzjFBaC8u2Kz3l3jqhlOb67Mg/ipvPZ1z/Ab6MQha15aJ1NlvHndPt2/93fAngcdf7CVDoXTjMepVuC3EVreZKq0sxJ+1rRYne+pdId7je1K+2xlqLSc862PS2nmqEqLYd8VMCaUhQeHpdg5uKmV9cpfvnwGoa2aP4VDNcpR0Z1SNtS0Nw+dHOH72nF3rq2HRhuWZ+Jr/TPkzmism1vicLVcshHBawpReHxNfty8Az6VoxfwRsDhmGZ38hfVW+Jwtm58CFReF8rWuzOtxRHtMf0on6lyWm7VufCG3JEZdu+Iwqn5ZCPClgTR+H5DWrh68dpXe9yl+Kff/v7lxB3pfz3aUHQvbF0fF9a/E61NONRNgeSKydcF87sU7+mlMuctL0VrXbkW4qzPVmf2Klce6FdmbXsXTmiora7X7MP2VqGqrQPyUcFlPGpDQDoiSgMAD0RhQGgJ6IwAPREFAaAnojCANATURgAeiIKA0BPRGEA6IkoDAA9EYUBoCeiMAD09H8Oujec37MBPAAAAABJRU5ErkJggg==" alt="" />

大家都是同级的，就会逐条执行，这个例子还说明了什么叫逐条执行，当我执行的 print d 时，d的赋值操作却在后面，所以进行打印操作的时候，没找到这个变量的值，所以抛出了给变量没定义的错误。

而我们要进行流程控制的操作的时候，我们希望的效果是这样的：

a = 1
if a == 1: #如果a的值等于1的话，注意赋值运算符和比较运算符号的差别
print a #我就打印出a的值

假设这里没有语法问题，python从第一句开始执行，当判断完 if 之后，又换行继续执行。

本来我们是想让 if 来控制 print 执行的，但 print 表示不服，大家都是同一级的，你 if 凭什么管我？

当然，这种写法是一种语法错误。

aaarticlea/png;base64,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" alt="" />

所以，我们可以认为缩进是python控制优先级的，它规定了代码间的管辖问题。（这是我自己总结的）

但是，当我们学到函数，学到类的写法的时候，发现其也是要进行缩进的，而函数中又有一个作用域的问题（到时候详细讲），在函数作用域中又有一个现象，函数内外的变量是不能互相访问的（当然也有强制的方法），此时有人就会搞混了，是不是我这里流程控制使用缩进分了内外分层后，内层的变量在外层也是不能访问的？

不是，下面是实例：

a = 1
if a == 1:
b = 1
else:
b = 0
print b

aaarticlea/png;base64,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" alt="" />

是可以访问的，注意作用域是函数的东西，不要混到流程控制里面起来，为了方便大家了解，我画了下面这幅图：

aaarticlea/png;base64,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" alt="" />

是这为了方便大家了解才画的图，具体python内部是不是这样处理的我也不知道。

在缩进的时候可以使用制表符（tab键）和空格，官方推荐是4个空格，但这两种缩进方式是不能混用的。

但是，如果我们使用IDE编程（部分，pycharm中是这样）的话，当我们按下 tab 键的时候，IDE会输入若干个空格（默认个数也因IDE不同而不同），也就是我们认为我们输入的是 tab 键的制表符，其实输入的是空格，这点要注意。

关于python中的编程风格可以总结为：

Python 使用硬回车来分割语句（一句一行，一行写不下用 \ 换行），使用冒号(:)和缩进来分割代码块。同一层次的语句必须有相同的缩进（每一组这样的语句称为一个块），而C语言风格的编程语言(Java/C#/C++)则使用分号来分割语句，花括号来分割代码块。

1.if 语句

python中使用 if...elif...else... 来实现条件判断：

a = 1
if a == 1:
b = 1
elif a == 2:
b = 2
elif a == 3:
b = 3
else:
b = 0
print b

python会从上到下进行判断，如何条件为真，即布尔值为 True ,其内层的代码才会被执行。

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIcAAAAsCAIAAADAXjxwAAABYklEQVR4nO2Z2xLDIAhE/et+vn1qLqIGR5CN3TOdTuoYELdgSlMWpB9yvDqtNS4ta1DabHlXrjPdaTm6fmxN1kT0OKe8ZWCqiHbUmSEd7zNfiHkjJotRSW2eEJP4LSk2rnMZse5JFaqCSKnKp5a8+sHFhJcaJ6Y0iBUG4QBwoh7Vi4QJ9O5HMypbYTTPNkmgMfs45430orISxuN3gIc1HBblSlakC3PlYNG5cu1hqNc2YHYzVjyDsYKNsuj3ymhpGrJpYg2KDUPaAKqCCFVBhKogwu4kIuxOIsLuJCLo3cl+G+bvVMnsTsaB3p1krpywOxkLu5OIsDuJyIYhbQBVQYSqIEJVEClVSen2IiFUVCneyXrqG089YlGpclQzeVFc58zqZ4A2V+RGF0p0BskoA6p0Roq8YbpMYq8KmcdAleKM6dxClFR2TtafVlHqHP6UZAZuHiJUBRFfVXb9/8MbqoLIF3j0bWaMKerfAAAAAElFTkSuQmCC" alt="" />

这里比较运算符返回了布尔值，但是如果条件不是布尔值或者没有返回布尔值要怎么判断。

其实，当我们用某个作为判断条件是，其实已经隐性地声明要使用 bool() 函数将条件强制转换为布尔值了。

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJoAAAB9CAIAAADV3O16AAAD5ElEQVR4nO2c/ZKkIAzEeet7jXlj7o/dch1IYlQipulfbV0xFPJhDwix50qttdZaSqkdTeb+45YWM/346zQa6tvVenJ4odGQ2BPx8gv3wd/6Qd+2HhzelLJDzL88AE+dWuvOfpZvtIb2H7XCnhEdlrEvd45dKOnv1s1e3sRo/c436X4lozozpnUhK2AK3iSuS3PHNRyQYZAfKCcU5Z+0zvgznwRsYYyg1DPiTVQ0YtuCx+99eb+ilNPD330Zq6hnYSwddmExTfZ83ZdRikaf5yinRtTsrI4Jytk5nKhn53bHOTufJGRny8V2FlHnTv8qeqHOIbVBwlsDBeWEgnJCQTmhGL8VCt2tcB9kE35QGQi3tYeEhBE4O2cREuTzx+3OHk8pp02aEHxEbXhEzU4x3Rfj7BxL+LOTs/NJ0oTgI2rDIyQEPzz43lQ7sE4weGugoJxQUE4oKCcUmVzwVfmZY78/WnbTFHJQCUKUrU+v7CqKcvIF4ZHTKA9PlM/Wc/QcG+SjnBUmBK89Uwc2nYLwELxdbMjsPDtlgUn/+tpua0U584bgubNtCHfBX++ao05trV763ElgoJxQUE4oUsrJ3azG+K3Qp3w+5XOnTz81aJXcDB5hE3JQuSmnXQnlNAgJI8TJ6ddpTUVDgnzbatlI4s+sbjm1I+bqctZxiu6V2NL+TPHjb3fdL8hWl3Ps7OzTEXJumf0EXVrOuGdntJxiqFYsuQLhO9uxclZ9gV058r4REoK/uRXaX96L2s/CPgq/rpyzO3AFRoU01h05JJQTCsoJRSml7v/MosdlyFy+9g0eqSjnmzm9DaScb+ZPzkYnbWkVc/rCXJmnUDQxxLT9UfxmUNEnUWdnVWaYVky8kBP0YdRnp7EI2+WNMiQaWU4utkkp2nrYL5jiEqotqlxpp8D7DQXlhIJyQpFSTr7v1Ejsgjd+8resorld8JSzIbcLnv8rQkNuF7z402ux5CLQBQ9Fbhc85WzI7YKnnA10wUOR2wWvbYXWlXN2B67AqJDGuiOHhHJCQTmhOOGCJ++nbMaR7V+Sl+1l09xukDHIcjZ2r32iSW8f+YV4A+rstA3T9GC+E0tOI0c0ZlLO6QyQk7yHK3I2z1HjEvIwpUp7GdvbXjtFudK+BIoABeWEgnJCkVJOvu/USOyCN1hW0dwueI2l5axpXfAGayqa2wVf6f76hi54KHBc8HbJRcBxwdslF4EueChyu+DrbitklFmHlMNmVEhj3ZFDQjmhoJxQ0AUPBV3wUNAFDwVd8FDQBQ8FXfBQ0AUPBV3wUNAFDwVFgIJyQkE5oaCcUIS4EcgsQrxCZBb/AfAGowc9E1tdAAAAAElFTkSuQmCC" alt="" />

我们可以将不是bool类型的数据强制转换成bool值。那究竟它们之间的转换关系是什么呢？

下面是一些关于布尔值为假的总结：

1.数字0（0.0等浮点型也是）

2.空的数据（包括空的字符串，空元祖，空列表，空字典，空集合等）

3.None（空的对象）

除了上面为假之外，其他均为真。

注意，虽说在将布尔值强行转换成数字的时候：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIcAAAA2CAIAAABiEx2NAAAB5UlEQVR4nO2a7W7DIAxFeeu9Rt7Y+7NFCGzHKHxct/eoqtbUiZFPYYlwkVSUUj4+o4i0KX+0QcQPOlzlGorvuQt0lat5+XkfY4J5t/HKwaiYCE756urUYZGKp7ciR8VY5WtKM1rllzN1sxgz2UQx/Rpyf6yP+4uSZaWJtE5Xj1gDe8y+Gi/Z3Bmjlq//Kj5X1Jo66ayPkWGgWJm+iEXq0ofdBOeKGL93K0w9sf8KwsqK/yuLrFhZHq3EU/fZV7PvHmzUir+4qxVctIKdvwdbNEualcH6u45Xxto9rwzlsu4s1NPVvNs48OD6hi99ticI0AoitIKIYqWUvxc5RVv7WgbFnIJWEKEVRGgFEVpBhFYQoRVE+LyCCGuPCK0gQiuIJLOydLfjyFaKSsreSXlqU5qS4iC5eyfr9yngWpEMvZN+8BsQxGTtnbxP6RP513dG5STaTNbeSSvY788DbJNUydo7aQX7RyLzEtcKfu+kFRy3Yo0T1EqK3kkrxjkSWTMRlEjS3snmsmqiPlI6MZjLl/DZftvFh0AZB6mhFURoBRHdCswC+6WYO8TkIJwriNAKIrSCCK0gQiuI0Aoi7J1EhLVHhFYQoRVEPsHKrH0R3P2VFU0UL7u2/AbJppTln8fLqpEgYn4BNXXj3c21nxcAAAAASUVORK5CYII=" alt="" />

True转换成 1，但并不是说只有数字中只有 1 为真，只要不为0的数字都是真。

讲完布尔值的问题是时候分析语法了，首先，语法和核心就是使用关键字判断其布尔值是否为真，若为真，则执行内层的代码。

if 和 elif 里面都可以放条件，而 else 则表示如果上面的条件都不为真，则执行这里面的。

但要注意几个问题，一个判断组有且至少有一个 if ，可以有0个或多个 elif ，0个或1个else。（判断组也是我总结的东西，我也不知道python中有没有关于判断组的定义）

a = 1
b = 0if a == 0:
b = 1if a == 1:
c = 1
else:
b = 3print b
print c

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAccAAAA9CAIAAABX4DUuAAAGOklEQVR4nO3dy5WjOBSAYYVFCJNIKQwcwbDzZmYyYFvaOwo2ZOAk6AUvPa5A2BfK0/1/p0+dLreQhB4XIWO3+QcAoMcMAAA9RFUA0ERUBQBNr0bV/lFVj/7d0jtramNa924+ks+v4TVcaxTaQaWsZ1NtN2Zn95u6JM1PKG1n9RGl2iDnjZYrx+FPE6PqOPpvxtyM7TIHPpvq3niN5Ox8iLnZA5380pjoH5Wpw7K8Ok+dF9fwVZ82jUt6J0hs3dQ71g19cy878MWKzd2Ra7Ttxnw2X7sTryTN9fxz36U7op5NpZXbobP4kJw/kRBV++ZeNc9hGIahs/nLi5dsmBKPY6V/VJuDpm8e3r++MMK8eeXa+bLfNXOd3ZxdUsNSb9fwRIW9M1kXCMtZnHY6/mKkf1RGnEUXNWbYg+ceNQxHF2I/P6LkMw3PQrMNz8v5IwlR1V/ieWeSDIX4Frswqkb5vDDC/EPiw4Omf3ET4P0anudZ2jtT4nTxeNLphIsR1xrbWmFFfE1jvlbKy3U7uhD78RG1O1pyaT4t5w8lRNXy2jsbNZZ/Vz79at24orwZ035Pfxn/rJO8ae7G3NZ15XSDP4aPaR8qTjMmTNbLTZjAr6GztTGttfWczxU1DAhH3Zs+3GgL0qSOjK1ggSBE1XXTJlxjTqXPbeKmF/NHxWWNzR7emY65VffKtP82d2PuVVWbqv2q6qnFluLWCietGqeR6hP24HfmLKadkGUHSej3otYIz72zpra2NeZmbZvv084G4zAZmbmy0rGRNkiaZtkuGy9y4plGPbjbGuLovT7neBjszO7LgvJbUXVwrbdDl0749RbVNen0Xn6t51YYX5+XY+tKM00zDOINvnvEwSiuYW1dmPOZNQwty8yl0DHu+BuFaZpIeVTNLRA2Fq1p6Z01tRHvSLbKmvJxdo6YfouZ9nvo7DRtxp+5Ow+xVUvuJIR8MmexkbPcy8mdfnDuzo4n3rq+c/1Wq8bjUHolLCutT1ptcYzV8yone4cnLbczrbE1ei/OOVI4u6+wswMw9M/N2mx31Rz4XJtf/2/M9q1A4M3YlbPbE0zI57waSm1VJ9fbMbJsp/E9S3sn3unLxZFoDRWVnotZyYopLitazwalf0+/+j+jSm7XObl4x6v7gsi7Ln/KS8/kE67Zq+YRvsu/0aqHBlLun9IOLenB8EVhX1i6Mu2M3mtzzp7U9uy+wt67VXtvFnu32NlVjBEHgesyw0hcIwRp+ua+NNPe3mJUw/Rqf0oNJV5AnKLhfE1e75TTNLGy3hEXCOtqcazq8v5efF5r6cLclo4Ky+ofX/MFb1y7rTm71ihH1bQ+Q74Hk5yD9wCiozZ6ebuda9tEAyxt1TTnkrLK16r+GJtqKMyU9UzTfeFMawwbo/fKnFOFs/sK209W7d5qLbfY8yHpfatrw0XlnNJ262XKdsHeh7DP4qf576/14naTtg7FGo4J7lU177acWMMlcISCHa7lFq+T9lW3n2nb6x3pLel4J1F8Qssv3dvM8tonOUpeqAY7zm6Y14a2taY21d/zzuP009tMjPflg1aN02TOwu9B+SyWfd72q6q9R/FqqTX8fdUwH6mdnW3d8HTOKyvu065puiYYh+HIzNVZ3nMPuz4dP3NuQifKPSiliXPOjN7LcpavlCWz+wrvf7YqXasHpLvyiy01zC1mf7yGuq58NvDPeg4xpHjuu7e3eXsPMu75bZ5R/aDZfd4nVrv1PbjPML1ZHKxtP6uG+DMlI7PEsh2p8lGX/72Pmt18DwAAaCKqAoAmoioAaCKqAoAmoioAaCKqAoAmoioAaCKqAoAmoioAaBKjat9UxhhjKj61AQDHiN9ZVc1f5WuJqwBwiPj9qkssJawCwDHi/wXgfbW54btHAOAAoioAaGIHAAA08W4VAGjiySoA0MSnAABAE1EVADQRVQFAE1EVADQRVQFAE1EVADQRVQFAE1EVADQRVQFAE1EVADQRVQFAUzaqOst3AALAYVJUddYYY/hmVQA4LrdW5fuqAeAVRFUA0ERUBQBNRFUA0ERUBQBNG88A8BwAABzGpwAAQBNRFQA0EVUBQBNRFQA0EVUBQBNRFQA0EVUBQBNRFQA0EVUBQBNRFQA0/QJOYLnX6kWMXQAAAABJRU5ErkJggg==" alt="" />

即为第一组的 if 判断失败后，不能去执行第二组判断的 else。

另外，还有这种情况：

aaarticlea/png;base64,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" alt="" />

有两个条件是一样的，这种情况会怎么样，我们先看看结果：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAcwAAAAkCAIAAACL2Z2KAAAFlElEQVR4nO2cwZXcLAzHKYsS0shShqeCcPPpSwdcl/tU4Ys7mCb4DgYbgcDMjPF4k//v5e3LTrAQkpCF7IlwAAAAuiE+rQAAAPzNIMkCAEBH3kiy813K+/yuApMSgxDGviuH4/oanoM14gA7HDLXQ8u6MSe1b+qWMZ+g1c6HR9ShBukXLWfG4ZUoJdllM9yEuAk1lceMOrKZVeEScVNP+PylEJnvUgx0rkhn78tUw1e52q5u8Q4ZrKz3jrJu1mPbhS8qFtxRMlrdmA/9tbsPW8acT7z2XY6NqIeWR0l7ahUXkXx1+CQ761Hqh3POuUmVbz7RMOcHL6Ez32U1hmZ9j/71hYCLtpk1oSiYdNDZBnGZhq28rWFHGr3j2cqHdRXdlhOXKvNdCnZTnWRM6sG+Vzn3bJn2+YjiV0pXcaQN+0m+PHySjQvAaGFZZKTn8cYkm8h5IeDiS9LLiSde7Bi8r2E/Hq3e8YPz0rLTcmipYo1QRjH18jnGfG2Wl3V7tkz7eETtRktpzNUk/wD4JNu+GKsS28VHeP+rsku9eRPCfPu/LH+2Pa/1KMRtqzp9N2DJJr6HlY5ZBmbVtKYDYg2tGoQwSg1BzhkaEpirRj3TJh0Zk/NMqJHygUmyW4eHVqB+9mAT6z8sX5XOtZidHmMXaXKUwvynRyFGKQchzZccvMXW6TaFM6umYzh9qAe/C6vwbZO13cT4vckadO2TEoNSRoibUqbs00mROMwiszRXHhu5QfIxa29tueexK008uGsNNnrPl5yGwc7u/kiOfjfJOmui7l6+/7fzrNX5bl9/HYJRls9DsbbVofkY59hugL2nuSnVcFCWSu6pIWUtQtdJlzQUNxnzMQntSbZUPlRK2nz2SYlBsOeV2lxejlUhgcYWE+bbTcrvouVn6VzCWrXlnMHIKayiIpn3ctYWIGu3alm4sfNk55pV0zjkPqFz5frkarMxNoSip3j+44rxgjVq0Xuy5ITG3X02++0CNz+qytU9F/KgNeXDQmXz1/JCtIE3rKrvN0ZOPw05Ww3Z3XhJNPUxMY9W76RdwlJaSSqsZPZSCsvqqXSupNols3/7X+OfiZJ1nbN7eVr7NyTirThqn70gh1b0Ut/p+wMVqz4VSKV/yh3a4kH6IdNT5m5UO9F7ruTiouq7+2waHnztPYaOzuPFGkewMWGnQlSxFQQZM+txtdpeXzLRMK8FumjIEeVHnxzDHXs7VudjUtq8w5YPWy25qLo+KkzXtc3ObHXuKjrXfP8K97+lstskWyMOTrK5Pq7swUwyeX6QXFXxct3Og9JJgOVWzSW3zNVeycYx5jVkdsq20rynXLCGq0TvmZJzGnf32ey+wrV7LlvP4+GS/JBrDS05w0g1bTcxNZG+CdOjicf8+bXd+m5c25HVcBkwShk6NR01XPMIhXTH1vPgxPVk6y/P7XmHe9iddiHZV8Hi2aNGWGSf7Cq+jCXdautC5aiMEoOQv0PX0v+MGpFpT59YNR1TWEXsQX4Va4/YfMkheudv4KwR92SpHM7OVhnrHtZGc6U+nbSeNIlDGpklnfl+PXV9Hj9BGuNE3oPcmFRyIXpPk8zfOFt299kc8o2vvLAncEf4k1k1LJW6H9fwWM58J/Hfff/x0LXvnoXL7L0xucdf827sRXd316/VTtvTvWvgH0OTyvdaGoJ/kywyW1hbmYd84+bHc9ndjf+7AAAAOoIkCwAAHUGSBQCAjiDJAgBAR5BkAQCgI0iyAADQESRZAADoCJIsAAB0BEkWAAA6UkuyVn38uxIAAPCzKSRZq4QQQiDJAgDAW1QqWauQZAEA4D2QZAEAoCNIsgAA0BEkWQAA6AiSLAAAdKT+dgHeMAAAgLfAlxEAAKAjSLIAANARJFkAAOgIkiwAAHQESRYAADryPzlBS5mV1WLWAAAAAElFTkSuQmCC" alt="" />

很明显只有第一个为真的有效果了，所以我们可以得出以下结论：

一个判断组里面，一旦条件为真，这个判断组内剩下的判断就不继续进行了，当然我相信应该没有会写两个一样的条件吧。

三元运算

在讲完if语句之后，我们就可以学习三元运算了。

何为三元运算，这个名字看起来很高端，但其实是为了满足：我要为一个变量赋值，当满足一个条件时，这个变量的值应该是123，不满足的话值为456。

a = ???
if a == 1:
b = 1
eles:
b = 2

但这样写还是太烦，有没有简单点的写法？

有，我们可以使用三元运算：

b = 1 if a==1 else 2

总结起来就是：

b = 值1 if 条件 else 值2

这就是三元运算，就是这么简单，so easy。说白了就是一种高级的赋值方式，就算不用三元运算，用原始的写法也是可以的。

2. while循环

本来while循环应该放到循环里面讲的，但是while循环和bool值的关系比较密切，就在这里一并讲了。

首先 while 循环的意思是，当给定的条件为真的时候，就会对其内层的代码循环执行，从内层第一句执行到最后一句。执行完以后又回到while中继续判断条件，若还是为真，则继续执行，如此往复，直到条件为假。

a = 1
while a <= 5:
a += 1
print a
print '----',a

aaarticlea/png;base64,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" alt="" />

注意，最后一句 print '----',a 不在while的内层，不受while的控制，只要while执行完了，就一定会执行它。

这个时候，有同学要问，如果我给的条件永远为真， while True：那会怎么样？

那么，这时候要恭喜你，你进入了传说中的死循环，这个循环永远执行不完了，其后面的代码也不会执行了，这个时候连退出都要用 ctrl+c 强制退出了。

正是因为while循环这么危险，所以有两个关键字可以用来跳过循环：

continue 跳过本次循环

break 跳出整个while循环，当然有多个 while 嵌套时，只跳出当前这层

那么什么叫本次，什么叫整个，什么叫当前这层呢？

假如，有一天你在街上摆摊，生意很好，人们都排队来买，这个人买完就下一个。但是，此时你看到一个人长得奇丑无比，你不想卖给他，没办法，有钱任性呗。这是你大喊一声：东西不卖你，下一个继续（continue），这就是跳过本次循环，遇到这句时，下面的代码不继续执行了，继续回到循环的第一句执行。当然那个被你拒卖的人后来会不会找人揍你，这就不在考虑范围了。这个时候，又来个一个客人，你定睛一看，我去，城管！赶紧跑！这个时候你摆摊的行为就结束了，也就是 while 循环结束了，就算你的指定条件是到下午5点收摊的也没办法，这就是 break。但虽然摆摊结束了，但你还得继续生活呀，生活也是一个循环，不能因为一个城管就结束掉整个生活的循环呀，这就是只结束当前这层循环。

a = 1
while a <= 10:
a += 1if a == 5:
continue
if a == 8:
break
print a

aaarticlea/png;base64,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" alt="" />

另外，while循环也可以和 if 一样使用 else。

a = 0
while a<= 5:
print a
a+=1
else:
print '条件为假了'

aaarticlea/png;base64,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" alt="" />

不过一般很少这样用了，因为while循环条件为假是会自动跳出循环，此时会自动执行下面的同级代码，所以直接写在while的下面的同级处就可以了。

但是，这样写能够提供代码的可读性，具体如何选择看个人需要。

剩下的 for 循环会在后面另起一篇说明。

关于布尔值和流程控制暂时就是这些，后续有需求的话，我会进行补充说明。