Python之for循环

for循环在Python语言的流程控制中是非常重要的，在编程中有很多场景需要使用到for循环。举个例子，当我们需要把字符串中的每一个字符打印出来的时候，我们怎么实现呢？
我们当然可以使用之前学习的指定位置的方式让每个字符打印出来。

s = 'ABCD' print(s[0]) print(s[1]) print(s[2]) print(s[3])

但是，这是字符串s比较短的情况下可以实现的，当s拥有成千上万个字符的时候，难道我们要为此书写上万行代码吗？这个时候for循环就可以派上用场了。

s = 'ABCD' for ch in s:     print(ch) # 注意缩进

在上述代码中，ch是在for循环中定义的，意思是把字符串s中的每一个元素依次赋值给ch，然后再把ch打印出来，直到打印出字符串s的最后一个字符为止。

任务

班里考试后，老师要统计几位同学的平均成绩，已知5位同学的成绩用list表示如下：
L = [75, 92, 59, 68, 99]
请利用for循环计算出平均成绩。

Python之if-elif-else语句

在100分的考试当中，分数达到或超过90分是顶尖的，达到或超过80分是优秀的，如果想对达到或者超过60分的学生进行不同的分类，使用if-else进行判断，代码如下：

score = 59 if score < 60:     print('抱歉，考试不及格') else:     if score >= 90:         print('恭喜你，拿到卓越的成绩')     else:         if score >= 80:             print('恭喜你，拿到优秀的成绩')         else:             print('恭喜你，考试及格')

在这个程序里，我们做了多次分类，第一次，我们把低于60分和大于等于60分的分开，第二次，我们把大于等于90分和小于90分的分开，第三次，我们把大于等于80分和小于80分的分开。
这样写，我们得到一个两层嵌套的if-else语句，这样的实现可以满足我们的要求，但是如果继续增加条件，比如继续判断高于70分和低于70分的话，那么这个代码将会缩进越来越多，代码逻辑看起来也不够清晰。
我们可以使用if-elif-else语句来简化以上的逻辑。其中elif就是else if的意思。

score = 59 if score < 60:     print('抱歉，考试不及格') elif score >= 90:     print('恭喜你，拿到卓越的成绩') elif score >= 80:     print('恭喜你，拿到优秀的成绩') else:     print('恭喜你，考试及格')

这样，我们就可以写出代码结构非常清晰的一系列条件判断了。
特别注意: 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。
请思考以下代码将会输出什么？为什么不输出恭喜你，拿到卓越的成绩。

score = 95 if score < 60:     print('抱歉，考试不及格') elif score >= 80:     print('恭喜你，拿到优秀的成绩') elif score >= 90:     print('恭喜你，拿到卓越的成绩') else:     print('恭喜你，考试及格')

任务

如果年龄达到18岁，则是成年人，如果年龄6岁到18岁，则是青少年，如果年龄3岁到6岁，则是小孩子，如果年龄在3岁以下，则是婴儿，请使用if-elif-else语句实现逻辑，如果成年，输出'adult'，如果是青少年，输出'teenager'，如果是小孩子，输出kid，如果是婴儿，输出baby。

Python之if-else语句

使用if判断，可以在当if条件为True时，执行if的子逻辑分支，但有时候，也想在if条件不为True时，执行别的子逻辑分支。
比如：在上一节课的例子中，我希望当分数小于60分时输出，抱歉，考试不及格，否则，输出恭喜你，考试及格，这个时候可以使用if-else语句。

score = 59 if score < 60:     print('抱歉，考试不及格') else:     print('恭喜你，考试及格')

这个时候，程序就会根据score的值，走不同的子逻辑分支，同学可以改变score的值试一试。
在这里，同样需要注意两个地方，第一个是冒号:，在else中，同样需要冒号；其次是缩进，在else的子逻辑分支，同样需要缩进。

任务

如果年龄达到18岁，则是成年人，请使用if-else语句实现以下逻辑，如果成年，输出'adult'，否则，输出'teenager'。

Python之if语句

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断，通过条件判断，选择做什么样的逻辑（当然，逻辑是需要我们提前写好的），我们称之为条件分支判断。
举个例子，在100分试卷的考试中，小于60分我们认为是不及格的，因此，我们可以使用程序自动判断考试是否及格。

score = 59 if score < 60:     print('抱歉，考试不及格') # ==> 抱歉，考试不及格

这里，因为score = 59 < 60，所以if的判断是True，因此就会执行print('抱歉，考试不及格')。
这里有几个需要注意的地方：

可以看到print('抱歉，考试不及格')这行代码明显比上一行代码缩进了，这是因为这行代码是if判断的一个子分支，因此需要缩进，在Python规范中，一般使用4个空格作为缩进

在if语句的最后，有一个冒号:，这是条件分支判断的格式，在最后加入冒号:，表示接下来是分支代码块

任务

如果年龄达到18岁，则是成年人，咚咚呛的年龄是19岁，请使用if语句判断咚咚呛是否成年，如果成年，输出'adult'，并把咚咚呛的年龄打印出来。

Python的字符串切片

字符串由一个个字符组成，每一个字符都有一个唯一的位置。比如字符串'ABC'，第一个字符是A，第二个字符是B，第三个字符是C。
因此我们可以使用位置的方式取出字符串中特定位置的字符，按照位置取字符串的方式使用中括号[]访问，这个时候可以把字符串看作是一个列表（一种新的数据类型，在后面会继续学习），不过需要注意的是，在程序的世界中，计数是从0开始的，使用0来表示第一个。

s = 'ABC' a = s[0] # 第一个 b = s[1] # 第二个 c = s[2] # 第三个 print(a) # ==> A print(b) # ==> B print(c) # ==> C

有时候，我们会想获取字符串的一部分（子串），这个时候我们采取切片的方式获取，切片需要在中括号[]中填入两个数字，中间用冒号分开，表示子串的开始位置和结束位置，并且这是半闭半开区间，不包括最后的位置。

ab = s[0:2] # 取字符串s中的第一个字符到第三个字符，不包括第三个字符 print(ab) # ==> AB

我们定义一个更长的字符串，了解切片更多的细节。

s = 'ABCDEFGHIJK' abcd = s[0:4] # 取字符串s中的第一个字符到第五个字符，不包括第五个字符 print(abcd) # ==> ABCD cdef = s[2:6] # 取字符串s中的第三个字符到第七个字符，不包括第七个字符 print(cdef) # ==> CDEF

任务

请从字符串'AABCDEFGHHIJ'中，使用切片的方式取出'ABCDEFGH'。

Python的字符串切片

字符串由一个个字符组成，每一个字符都有一个唯一的位置。比如字符串'ABC'，第一个字符是A，第二个字符是B，第三个字符是C。
因此我们可以使用位置的方式取出字符串中特定位置的字符，按照位置取字符串的方式使用中括号[]访问，这个时候可以把字符串看作是一个列表（一种新的数据类型，在后面会继续学习），不过需要注意的是，在程序的世界中，计数是从0开始的，使用0来表示第一个。

s = 'ABC' a = s[0] # 第一个 b = s[1] # 第二个 c = s[2] # 第三个 print(a) # ==> A print(b) # ==> B print(c) # ==> C

有时候，我们会想获取字符串的一部分（子串），这个时候我们采取切片的方式获取，切片需要在中括号[]中填入两个数字，中间用冒号分开，表示子串的开始位置和结束位置，并且这是半闭半开区间，不包括最后的位置。

ab = s[0:2] # 取字符串s中的第一个字符到第三个字符，不包括第三个字符 print(ab) # ==> AB

我们定义一个更长的字符串，了解切片更多的细节。

s = 'ABCDEFGHIJK' abcd = s[0:4] # 取字符串s中的第一个字符到第五个字符，不包括第五个字符 print(abcd) # ==> ABCD cdef = s[2:6] # 取字符串s中的第三个字符到第七个字符，不包括第七个字符 print(cdef) # ==> CDEF

任务

请从字符串'AABCDEFGHHIJ'中，使用切片的方式取出'ABCDEFGH'。

Python的字符串编码

在python2中，字符串的编码问题是使用python2必经历的门槛，所幸到了python3，python3从编程语言的层面就减少了很多编码的问题，但是学习字符串编码还是很有必要的。

为什么有编码问题

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这种编码方式被称为ASCII编码，比如大写字母 A 的编码是65，小写字母 z 的编码是122。
如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。

python3的编码

在python3中，默认使用UTF-8 Unicode来进行编码，因此我们可以在python中输入任意形式的Unicode字符串，都不会遇到像python2中遇到的问题（在python2中，需要显式指明该字符串是Unicode字符串），如果没有了解过python2，则完全可以忽略这一点，python3提供了更加简单易懂的编码方式。

s1 = '这是中文字符串' s2 = 'this is an English string' print(s1) print(s2)

在python3中，中文字符串和英文字符串无异。

任务

请定义并打印中英文混合的字符串 "这是一句中英文混合的Python字符串：Hello World!"

Python的字符串format

字符串是Python程序重要的数据类型，到目前为止，我们输出的字符串的内容都是固定的，但有时候通过字符串输出的内容不是固定的，这个时候需要使用format来处理字符串，输出不固定的内容。
字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板 template = 'Hello {}' # 模板数据内容 world = 'World' result = template.format(world) print(result) # ==> Hello World

如果模板中{}比较多，则容易错乱，那么在format的时候也可以指定模板数据内容的顺序。

# 指定顺序 template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.' result = template.format('World', 'China', 'Beijing', 'imooc') print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc. # 调整顺序 template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.' result = template.format('World', 'China', 'Beijing', 'imooc') print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

除了使用顺序，还可以指定对应的名字，使得在format过程更加清晰。

# 指定{}的名字w,c,b,i template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.' world = 'World' china = 'China' beijing = 'Beijing' imooc = 'imooc' # 指定名字对应的模板数据内容 result = template.format(w = world, c = china, b = beijing, i = imooc) print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

任务

请使用两种format的方式打印字符串Life is short, you need Python。

# Enter a code

# coding=utf-8

# 记忆方法：模具，内容，合并了的模具

template = '林 {}'

# 模具

a = '书豪'

# 实体

result = template.format(a)

print(result)

# result由两个组成，字符串模板，模板数据内容（合并了的模板）

# format括号里边需要引号，除非上面已经定义

print('指定顺序')

template = 'hello {0},hello {1},hello {2},hello {3}'

result = template.format('world', 'china', 'beijing', 'imooc')

print(result)

# template='林[0],林[1],林[2],林[3].'

# result=template.format('书豪','国豪','俊杰'，'妙可')

# print(result)

print('指定顺序中变量设置为中文运行不了，什么原因呢')

# 发现原因了，原来是笔记本没有{}符号，换其他键盘可以打出

template = '林 {1},林 {2},林 {3},林 {0}.'

result = template.format('书豪', '国豪', '俊杰', '妙可')

print(result)

print('调整顺序')

template = 'hello {0},hello {1},hello {2},hello {3}.'

# template后面加不加点都可以

# 元素之间逗号后有没有空格都可以，一般建议有空格

result = template.format('beijing', 'shanghai', 'guangdong', 'hunan')

print(result)

# 1.等号两边需要空格

# 2.hello和数字之间需要空格

# 3.beijing的逗号后面需要空格

# 4.result变量前面需要空格

# 5.代码结束需要下一空行

# 6.#的后面需要空格

print('指定对应的名字')

template = 'hello {m}, hello {w}，hello {h}, hello {y}.'

meixi = 'meixi'

wujiayu = 'wujiayu'

huangshang = 'huangshang'

yazi = 'yazi'

result = template.format(m=meixi, w=wujiayu, h=huangshang, y=yazi)

# 这行的等号两边不需要空格

print(result)

print('指定对应名字 测试')

template = '3 {w}, 0 {c}, 2 {b}, 1 {i}.'

c = 'www'

w = 'ccc'

b = 'bbb'

i = 'iii'

result = template.format(b=c, c=w, w=i, i=w)

print(result)

#template规定了3021顺序，{c}对应c=w再对应w = 'ccc'，也就是跳了两次

# result后面是合体版本

# 模板数据内容有三条：

# 变量

# （如果有指定名字，则这行需要指定）

# result

# print

print('任务')

print('第一种方式，普通方式')

template = 'life is short,{}.'

a = 'you nide python'

result = template.format(a)

print(result)

print('第二种方式，指定顺序')

template = 'life {0} short,{1} nide {2}.'

result = template.format('is', 'you', 'python')

print(result)

print('第三种方式，调整顺序')

template = 'life {2} short,{0} nide {1}.'

result = template.format('you', 'python', 'is')

print(result)

print('第四种方法，指定名字')

template = 'life {i} short,{y} nide {p}.'

i = 'is'

y = 'you'

p = 'python'

result = template.format(i=i, y=y, p=p)

print(result)

print('第五种方法，自创最简')

template = 'life {i} short,{y} nide {p}.'

result = template.format(i='is', y='you', p='python')

print(result)

Python中raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：

r'\(~_~)/ \(~_~)/'

但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串。

如果要表示多行字符串，可以用'''...'''表示：

'''Line 1 Line 2 Line 3'''

上面这个字符串的表示方法和下面的是完全一样的：

'Line 1\nLine 2\nLine 3'

还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido". It is free and easy to learn. Let's start learn Python in imooc!'''

任务

请把下面的字符串用r'''...'''的形式改写，并用print打印出来：

'\"To be, or not to be\": that is the question.\nWhether it\'s nobler in the mind to suffer.'

Python的字符串

前面我们讲解了什么是字符串。字符串可以用' '或者" "括起来表示。

如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：

"I'm OK"

类似的，如果字符串包含"，我们就可以用' '括起来表示：

'Learn "Python" in imooc'

但是，如果字符串既包含'又包含"怎么办？

这个时候，就需要对字符串中的某些特殊字符进行“转义”，Python字符串用\进行转义。

要表示字符串Bob said "I'm OK"
由于'和"会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'Bob said \"I\'m OK\".'

注意：转义字符 \不计入字符串的内容中。

常用的转义字符还有：

\n表示换行
\t 表示一个制表符
\\表示 \ 字符本身

任务

请在Python中输出以下字符串special string: ', ", \, \\, \n, \t

Python的布尔类型

前面我们了解到，布尔类型是Python的基础数据类型，布尔类型只有True和False两种值，本节课我们学习布尔类型的集中运算。

与运算

只有两个布尔值都为 True 时，计算结果才为 True。

True and True # ==> True True and False # ==> False False and True # ==> False False and False # ==> False

或运算

只要有一个布尔值为 True，计算结果就是 True。

True or True # ==> True True or False # ==> True False or True # ==> True False or False # ==> False

非运算

把True变为False，或者把False变为True：

not True # ==> False not False # ==> True

这些运算有什么用呢？计算机程序是由无数的逻辑分支组成的，通过布尔运算，可以在计算机中实现条件判断，根据计算结果为True或者False，计算机可以自动执行不同的后续代码，因此学习布尔运算也是非常有必要的。

在Python中，布尔类型还可以与其他数据类型（字符串，数字等）做 and、or和not运算，请看下面的代码：

a = True print(a and 0 or 99) # ==> 99

得到的计算结果不是布尔类型，而是数字99，这是为什么呢？

因为Python把0、空字符串和None看成False，其他数值和非空字符串都看成True，所以：

True and 0计算结果是0 
继续计算0 or 99计算结果是 99 
因此，结果是99。
需要注意的是，not计算的优先级是高于and和or的。

True and not False # ==> True

在上述布尔计算中，先计算not False = True，然后再计算True and True，因此得到True的结果。

短路计算

在计算a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

在计算a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

Python的整数与浮点数

在Python中，整数和浮点数虽然属于不同的数值类型，但是在运算上是可以一起运算的，这从生活经验出发，也是可以理解的。

四则运算

整数、浮点数可以直接进行四则运算。

# 加法 num1 = 10 num2 = 0.5 result = num1 + num2 print(result) # ==> 10.5 # 减法 result = num1 - num2 print(result) # ==> 9.5 # 乘法 result = num1 * num2 print(result) # ==> 5.0 # 除法 result = num1 / num2 print(result) # ==>20.0

从上面可以发现一个规律，整数和浮点数运算后 ，得到的结果不管小数点后是否有值，结果都变成浮点数了，这是合理的，浮点数可以表达整数的结果，但是整数不能表达浮点数的结果。
注意：在Python2使用除法可能和Python3得到不一样的结果

# python2 num1 = 10 num2 = 3 result = num1 / num2 print(result) # ==> 3 # python3 num1 = 10 num2 = 3 result = num1 / num2 print(result) # ==> 3.3333333333333335

可以看到在python2，得到的是一个整数的结果，这是因为除数和被除数都是整数时，得到的结果也默认保存为整数了，这是非常不科学的，因此在python3，改进了这一点。

取模运算

Python数字支持取模运算，使用百分号%表示取模。

print(3 % 2) # ==> 1 print(33 % 10) # ==> 3 print(99 % 30) # ==> 9

恰当使用取模运算，可以判断一个数是否为偶数，当一个数对2取模结果为0时，则这个数为偶数，否则为奇数。

print(3 % 2) # ==> 1 因此3为奇数 print(33 % 2) # ==> 1 因此33为奇数 print(100 % 2) # ==> 0 因此100为偶数

地板除

Python除了普通除法以外，还有一个特殊的除法被称为地板除，对于地板除，得到的结果会忽略纯小数的部分，得到整数的部分，地板除使用//进行。

10//4 # ==> 2 10//2.5 # ==> 4.0 10//3 # ==> 3

小数点位数

使用Python计算小数的时候，经常需要保留小数点后若干位，可以使用round()函数来处理，这里先了解round的调用方式，使用两个参数，第一个是需要保留小数点位数的数值，第二个是保留的位数。

num = 10 / 3 print(num) # ==> 3.3333333333333335 # 使用round保留两位小数 round(num, 2) # ==> 3.33

任务

一个长方形的长为3.14cm，宽为1.57cm，请计算这个长方形的面积，保留小数点后两位。

length = 3.14
width = 1.57
result = round(length * width, 2)
print(result)

Python定义变量的方法

什么是变量

在Python中，变量的概念基本上和初中代数的方程变量是一致的。例如，对于方程式 y=x*x ，x就是变量。当x=2时，计算结果是4，当x=5时，计算结果是25。

合法的变量名

只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型（字符串、布尔值、空值、字典等）。在Python中，定义一个变量需要遵循一定的约束，否则，Python可能识别不出它是一个变量。

变量名由大小写英文字母、数字和下划线_组成

变量不能用数字开头

变量尽量不要和Python关键字重合（比如前面学习过的：and、or、not，否则可能导致Python原有关键字发挥不出作用）

以下这些变量的定义都是合法的。

num, count, _none, min_value

他们都满足上面的三个条件。

以下这些变量的定义都是不合法的。

1num, 666, 1_cd, and

定义变量

定义变量的方式很简单，通过变量名 = 数据，即可定义一个变量。
举个例子：

a = 1

在这个例子里面，a就是变量，它的值是一个整数1。

hello = 'Hello'

在这个例子里面，hello就是变量，它的值是一个字符串'Hello'。
在Python里面，一个变量可以先后存储多种不同类型的数据。

a = 1 # 这个时候a存储的是整数类型 print(a) a = 'ABC' # 这个时候a存储的是字符串类型 print(a)

这是Python这类语言特有的特性，我们称之为动态语言，与之对应的是静态语言，Python、Javascript等等都是动态语言，Java、C、C++等等属于静态语言。

任务

前面我们写了第一个Python程序，向屏幕打印了'Hello World'，请通过定义多个变量的方式，把相同的字符串打印出来。

Python基础数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。

学习编程，认识不同编程中的数据类型是必要的，在Python中，能够直接处理的数据类型有以下几种：

整数

整数和我们生活中定义的整数是一个概念，例如：1,2,3,10,100,1000,-1000 等等，都是整数，Python可以处理任意大小的整数。

对于整数，除了生活中常用的十进制以外，计算机由于使用二进制，所以，在计算机中也常用二进制或者十六进制表示整数。相比十进制数，在Python中使用以下方式表示二进制数和十六进制数。

二进制数只使用数字0、1表示，在Python中，二进制整数使用前缀0b表示，比如：0b0110，0b1100。

十六进制数除了0~9十个数字以外，还使用a、b、c、d、e、f，在Python中，十六进制使用前缀0x，比如：0x12ef，0xde2431af。

十进制数、二进制数和十六进制数之间是可以相互转换的，如果感兴趣的同学，可以学习《编程必备基础知识》了解更多转换的细节。

浮点数

浮点数对应我们生活的是小数，例如：0.1,0.5, 12.34, 3.1415926等，都是浮点数。

为什么小数在计算机领域被称为浮点数呢？这是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的（浮动的），比如，1.23x10^9和12.3x10^8是相等的，因此称为浮点数。

浮点数可以用数学写法，如1.23，3.14，-9.01。但是对于很大或很小的浮点数，就必须用科学计数法表示，在Python中，把10用e替代，比如：1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，同学可以自行举出更多的例子。

这里有必要提醒一点就是，整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差，如何检验，可以在Python终端中输入以下内容0.1 + 0.2，看看可以得到你期望的结果0.3吗？真实结果可能让你失望了。

同样的，这里涉及的原理同学也可以学习上面提到的课程进行进一步原理层面的理解。

字符串

字符串对应生活中的就是非数字类型的内容，比如一个句子，一段话，在Python中就是字符串，在Python中，字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。

比如之前练习过的第一个Python程序：print('Hello World')，其中的Hello World就是字符串。

布尔值

布尔值对应于生活中的就是对和错，在计算机的世界里，大部分判断都是非错则对的，布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写，不需要使用字符串符号括起来），也可以通过布尔运算计算出来。

布尔值可以用and、or和not运算（注意and,or,not都是Python语言本身的关键字）。

and运算是与运算，只有所有都为 True，and运算结果才是 True。

or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。

not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。

空值

空值是Python里一个特殊的值，用None表示。

注意，None和0是不一样的，None不能理解为0，因为0是有意义的，比如我有0个苹果表示我没有苹果，0表达的是数值0的意思，而不能表示为我有None个苹果，None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会展开介绍。

任务

请判断以下数据分别属于什么数据类型：

3.1415926 'Learn Python in imooc.' 100 0b1101

Python之if-elif-else语句

在100分的考试当中，分数达到或超过90分是顶尖的，达到或超过80分是优秀的，如果想对达到或者超过60分的学生进行不同的分类，使用if-else进行判断，代码如下：

score = 59 if score < 60:     print('抱歉，考试不及格') else:     if score >= 90:         print('恭喜你，拿到卓越的成绩')     else:         if score >= 80:             print('恭喜你，拿到优秀的成绩')         else:             print('恭喜你，考试及格')

在这个程序里，我们做了多次分类，第一次，我们把低于60分和大于等于60分的分开，第二次，我们把大于等于90分和小于90分的分开，第三次，我们把大于等于80分和小于80分的分开。
这样写，我们得到一个两层嵌套的if-else语句，这样的实现可以满足我们的要求，但是如果继续增加条件，比如继续判断高于70分和低于70分的话，那么这个代码将会缩进越来越多，代码逻辑看起来也不够清晰。
我们可以使用if-elif-else语句来简化以上的逻辑。其中elif就是else if的意思。

score = 59 if score < 60:     print('抱歉，考试不及格') elif score >= 90:     print('恭喜你，拿到卓越的成绩') elif score >= 80:     print('恭喜你，拿到优秀的成绩') else:     print('恭喜你，考试及格')

这样，我们就可以写出代码结构非常清晰的一系列条件判断了。
特别注意: 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。
请思考以下代码将会输出什么？为什么不输出恭喜你，拿到卓越的成绩。

score = 95 if score < 60:     print('抱歉，考试不及格') elif score >= 80:     print('恭喜你，拿到优秀的成绩') elif score >= 90:     print('恭喜你，拿到卓越的成绩') else:     print('恭喜你，考试及格')

任务

如果年龄达到18岁，则是成年人，如果年龄6岁到18岁，则是青少年，如果年龄3岁到6岁，则是小孩子，如果年龄在3岁以下，则是婴儿，请使用if-elif-else语句实现逻辑，如果成年，输出'adult'，如果是青少年，输出'teenager'，如果是小孩子，输出kid，如果是婴儿，输出baby。

#-*- coding: utf-8 -*-

score=80

if score<60:

    print('考试不及格')

elif score>=90:

    print('获得奖金')

elif score>=80:

    print('考试优异')

else:

    print('考试及格')

#判断是否成年

#-*- coding: utf-8 -*-

age=5

if age>18:

    print('成年')

elif age>12:

    print('青少年')

elif age>=6:

    print('小孩')

else:

    print('baby')