7.1.1 Python安装介绍《变量》命名规则，关键字，赋值，销毁《数据类型》数值，字符布尔，空，类型转换《运算符》算术，赋值，比较，逻辑《流程控制》条件，循环，案例

目录

======== 第一部分 Python入门 ========

第一节 Python语言介绍

第二节 Python安装及配置

1.2.1 Python版本介绍

1.2.2 安装Python环境

1.2.3 Hello World  

1.2.4 脚本编程

第三节 交互式编程

第四节 Python开发工具

======== 第二部分 核心语法 ========

第一节 变量

2.1.1 变量的定义

2.1.2 变量名规则   

2.1.3 关键字                                               

2.1.4 变量赋值                                     

2.1.5 变量的销毁    

第二节 数据类型        

2.2.1 数值                                                    

2.2.2 字符串   

2.2.3 布尔值(boolean, bool)                                                         

2.2.4 空值 None   

2.2.5 类型转换       

2.2.5.1 布尔值转换     

2.2.5.2 字符串转换     

2.2.5.3 数值转换 

第三节 运算符 

2.3.1 算术运算符

2.3.2 使用算术运算符操作字符串  

2.3.3 赋值运算符  

2.3.4 比较运算符  

2.3.4 逻辑运算符  

第四节 流程控制   

2.4.1 条件判断

2.4.1.1 if...else...语句  

2.4.1.2 elif    

2.4.1.3 if 条件嵌套

2.4.1.4 与逻辑运算符组合

2.4.1.5 自动类型转换  

2.4.2 循环 

2.4.2.2 for循环

2.4.2.3 嵌套循环 

2.4.2.4 break和continue

2.4.3 演示：智能密码锁程序               

---

 

======== 第一部分 Python入门 ========

第一节 Python语言介绍

第二节 Python安装及配置

1.2.1 Python版本介绍

Python目前有两个版本共存，Python 2 和 Python 3，其中Python官方宣布:Python 2于2020年1月1 日起不再维护，所以如果你现在开始学Python，肯定是要学习Python3了。

但由于Python2的生命周期较长，而且是刚刚停止维护，所以在许多公司中还在使用，有些面试官喜欢 在面试的时候问你:Python2 和 Python3有何区别?不要担心，他们的区别其实没那大，只要掌握了 Python3，很快你就能掌握它们的一些细微差别。

 

1.2.2 安装Python环境

1. 访问Python官网，https://www.python.org , Python官网会通过浏览器识别你的操作系统，所以

只要按下图操作即可下载相应的版本。

注意：这样会下载到最新的Python3 版本，如果想下载历史版本，可以访问这里：https://www.python.o rg/downloads/

1. 双击运行下载下来的安装文件，按照提示一步步的进行安装。
2. 测试是否正确安装。
   1. 打开控制台，Windows在搜索栏里输入"cmd"并回车。（Mac打开系统自带的"终端"应用程序）
   2. 在控制台内输入"python"，并回车，如果出现以下界面，则说明安装成功。

 

1.2.3 Hello World  

Python的代码以简洁高效著称，比如下面这四行代码，就可以实现包含10000个数据的正态分布直方图。

import matplotlib.pyplot as plt
import numpy as np
plt.hist(np.random.randn(10000), bins=40)
plt.show()

效果如下：

不要小看这4行代码，麻雀虽小，五脏俱全，它包含了几乎所有的Python知识。现在大家看不懂没关系，学完本阶段，你就会完全掌握，并觉得很简单啦。

接下来，我们来写个Hello world吧，Python的第一行代码绝对比你想象的简单，在上一步打开的控制台内，输入以下的代码：

print("Hello world")

然后敲回车键，如果你的显示器上显示了“Hello world”，恭喜你，你的第一个Python程序已经运行成功了，是不是很简单！试着把Hello world替换成你想说的话，再次运行看看。

这里的print是一个内置函数，关于函数的概念我们可以先不管，我们只要知道使用print函数可以在屏幕上输出指定的内容。print函数也可以支持这样的写法:

print("Hello", "world")
print("Hello", "my", "friends")

逗号隔开了多个单词，我们没有输入空格，但在输出的时候Python会自动用空格把每个单词隔开，实际上，我们可以输入100个，1000个无数个单词。大家注意逗号在这里的用法，后面我们会经常用到这种写法。

 

1.2.4 脚本编程

刚才我们在控制台里输出了Hello World，现在再来

 

第三节 交互式编程

 在上面的步骤中，我们输入了一行代码，按回车键后，将代码提交给了Python内置的解释器，解释器运行了代码后，将运行结果打印在了控制台上， 这种一次输入对应一次输出的形式，我们称之为交互式编程。

 试试将Hello world 案例中右边的引号去掉，看看会输出什么。

 你会看到一句话，像这样：

SyntaxError: EOL while scanning string literal

解释器尝试运行你的代码，但由于那个缺失的引号，导致执行的过程中出错，解释器向你打印了这个错误， 这时候屏幕显示的不是输出，而是error(异常或者说报错）。

一个有经验的程序员，看到这个error 信息后就能判断出是什么地方出现了问题。

 

第四节 Python开发工具

 

======== 第二部分 核心语法 ========

第一节 变量

2.1.1 变量的定义

 变量就是可变的量，对于一些有可能会经常变化的数据，我们需要使用一个符号，这样才能计算中使用它，就像我们在小学时学过的一元方程中的"x"一样。比如说，我们在控制台内输入：

x = "world"

这样我们就新定义了一个变量，它的值是"world"， 我们稍稍修改一下Hello world的例子，这次我们使用变量x。

print("Hello", x)

运行后输出的结果和我们之前的例子是一样的，在这里，x就相当于"world"。对于变量，我们可以理解为一个带有抓手的容器，我们可以往里任何我们想放的东西，而这个抓手，就是变量名，提着这个抓手，我们可以更方便的使用容器里的东西。

我们再写几个例子，巩固一下：

name = "Smith"
print("Mr", name)
print("Mrs", name)

在这个例子里，有一对史密斯夫妇，对他们的称呼应该分别叫Mr Smith 和 Mrs Smith，注意我们在代码中只写了一次Smith，就可以实现2次使用。还有一个好处是，假如换了一对夫妇，他们的名字不一样，我们只要修改name的值就行了，其他的代码完全不用修改，是不是很方便呢？

大家思考一下，假设上面的例子中，我们要打印100遍他们的名字，如果不用定义变量，那当我们修改时要怎么做？理解到变量的作用了吧？

 

 

2.1.2 变量名规则   

在Python中，变量名遵循以下的规则：

变量名由字母、数字和下划线组成，也就是a-z, A-Z, 0-9和_ 变量名不能以数字开头

变量名是区分大小写的，比如a 和 A就是两个不同的变量。

这个规则大家不用背，我们来举几个例子看一看，很快就明白了：

# 这些都是合法的变量名
a = "hello"
MyJob = "analyst"
player1 = "姚明"
_private_name = "ss"
player1_score = 41
_ = "something"

# 下面这些都是不合法的变量名
1abc # 不能以数字开头
123
abc- # 注意这是横杠符号，不是下划线

另外，在此基础上，我们也约定了一些变量名的命名规范。比如：

• 普通变量一般用小写字母
• 最好不要用单词加数字的方式来命名变量，尤其是没有意义的随机数字。
• 有两种风格的变量名:单词之间用下划线隔开;每个单词的首字母使用大写字母(也称为驼峰命名 法)

看上面的newUserName这种写法，是不是很像骆驼的驼峰。

注意，上面的规范只是程序员们的一种约定俗成规则，并不是Python语言的硬性要求。但是遵循了这些规范，写出来的变量名可读性更高，更有利于团队合作。

 

2.1.3 关键字                                               

以下的这些单词都是Python的关键字，每个编程语言都有各自的关键字，它们组成了编程语言基本的语法规则。大家先不用管它们的作用，只要在命名的时候避免使用这些名字就行了。

False      await      else
None       break      except
True       class      finally
and        continue   for
import     pass       not        
in         raise      with
is         return     or         
lambda     try        yield
nonlocal   while
as         def        from
assert     del        global     
async      elif       if         

事实上，如果你一不小心定义了一个与关键字相同的变量，代码会在运行的时候报错。比如下面这个：

True = 0
# 上面这行代码运行会输出下面的信息，提示不能给关键字赋值。 
# File "", line 1
# SyntaxError: can't assign to keyword

 

2.1.4 变量赋值                                     

变量是可以重复使用，并且是可以修改的，由于Python的变量不需要先声明，所以变量的声明和赋值是在同一行代码完成的，比如我们上面声明的name变量

name = "Smith"

在这一行里，我们先定义了一个名为"name"的变量，然后给它赋值为"Smith"，这样，我们就有了一个变量"name"，它的值是"Smith"。变量必须要先声明，才能使用。如果使用了一个从未定义过的变量 xxx，Python解释器会抛给你一个这样的错误：

NameError: name 'xxx' is not defined

 

在变量定义完成后，我们可以随意读取、修改它的值，比如：

# 定义name变量，赋值为"Smith" name = "Smith"
print("Mr", name)

# 修改变量的值为"Jones"
name = "Jones"
print("Mr", name)

这上面这个例子中，我们使用了同一个变量"name"，但它的值发生了变化，导致程序中两次输出的结果也发生了相应的变化。

现在我们掌握了如何给变量赋值，我们再来学习稍微高级一点的技巧，让大家领略Python的高效。有时候，我们需要定义好几个变量，以进行计算。比如现在我想要定义三个变量，并把它们的值都设为1，可以这样写：

a = b = c = 1

这样就定义三个变量，且它们的初始值都是1，那如果我想定义的三个变量值都不一样呢？

a, b, c = 1, 2, 3

大家可以试一下，在控制台里输入这样一行代码，然后分别打印一下a,b,c这三个变量的值、通过测试可以发现，这样写其实就相当于是：

a = 1

b = 2

c = 3

这也是其他大部分编程语言的写法，大家比较一下，哪种写法更高效呢？

我们再思考一下，既然可以同时给多个变量赋予不同的值，那可不可以直接交换几个变量的值呢？

# 定义两个变量，其中a=1, b=2
a, b = 1, 2
# 进行交换，现在a=2, b=1
a, b = b, a

这样的操作非常优雅、高效，大家可以试试更多的变量的交换。

 

2.1.5 变量的销毁    

在Python中，我们一般无需手动的去销毁变量，Python的垃圾回收机制会帮我们处理掉那些不再使用的变量，如果我们想刻意销毁删除某个变量，可以使用del关键字，像这样

del name

销毁后，这个变量就像没有定义过一样，再使用它的话就会产生异常。

 

第二节 数据类型        

如果有学习过其他编程语言的同学，可能在学习变量的时候就会想问，在Python中定义一个变量的时候，怎么没有先声明它的类型呢？

这正是Python的简洁高效之处。变量在Python中是不区分类型的，但它的值有类型，不同的值有不同的类型，我们来了解一下下面这三种基本的数据类型：

• 数值，包括整数和浮点数
• 字符串
• 布尔值

 

2.2.1 数值                                                    

Python中数值有两种类型，整形(int)和浮点型(float)，通俗一点的讲，一个是不带小数点的，一个带小数点的。

# 这是一个整形
a = 100
# 这是一个浮点型变量
b = 3.14

整形和浮点形数值可以相互运算，比如

# c是一个浮点型变量
c = a + b

这个很容易理解，一个整数加上一个小数，得到的肯定还是一个小数。我们再看另一个例子，可以先猜猜是什么类型。

a = 0.14
b = 3.14
c = b - a # c=3.0

这里面变量c还是一个浮点型，它的值是3.0，可以得出一个结论，只要有浮点数参与的运算，它的结果肯定也是浮点数。

 

2.2.2 字符串   

我们在Hello world例子中使用的就是字符串类型

a = "Hello world"

当如果字符串含有特殊字符，比如双引号，我们可以加一个\来进行转义。

print("Buddha: \"What we think, we become.\"")
# 输出的结果是：Buddha: "What we think, we become."

\  这个符号我们一般称为反斜杠

截止目前，我们在定义字符串时使用的都是双引号，其实Python也支持单引号，它们并没有什么区别。

a = "Hello"
b = 'world'
print(a, b)
# 输出的结果仍然是Hello world

这种灵活的写法给了我们便利，比如上面那个字符串中包含双引号的例子中，我们可以使用单引号定义字符串，这样就不用对字符中的字符串进行转义了，这样看起来是不是清爽了很多。

print('Buddha: "What we think, we become."')

有时候我们要定义的字符串比较长，超出了一行的长度，在编写的时候使用一个反斜杠"\"来连接多行：

sentence = "This's a very long long long \
long long sentence............"
print(sentence)

上面的代码在输出的时候还是会显示为一整行。如果说还有更长的字符串，类似一整段话，我们可以使用三引号

zen = """Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense."""
print(zen)

当然，上面的双引号也可以用单引号代替。

 

2.2.3 布尔值(boolean, bool)                                                         

布尔值只有两个值: True 和 False，顾名思义，True代表真，False代表假，我们用布尔值一般是用来做条件判断。在Python3中，True和False是关键字，所以我们不能定义为变量名。看起来，布尔值只有两个，但它们在Python是无处不在的，就像大自然中的水和火，那它们是怎么存在的呢？我们来看下一节吧！

 

2.2.4 空值 None   

空值None是Python中的一个特殊值，它代表空值，表示“什么都没有”，None同时也是关键字。None 的用处有很多，比如说你想定义一个变量，但一时还没想好给它赋什么值，甚至连它用什么类型也没决定好，这时可以先用None

temp = None
print(temp)

None被输出的时候显示为一个字符串"None"

 

2.2.5 类型转换       

2.2.5.1 布尔值转换     

要想把其他值转换为布尔值，需要使用一个内置函数bool()，我们在控制台按顺序输入以下的代码：

(关于函数的概念我们在后面的课程中会学习，Python的内置函数有很多，我们也会一一学习。)

# 以下值都为True
bool(1)
bool(-1)
bool(255)
bool(0.0000001)
bool(-99.99)
# 下面的值为False
bool(0)
bool(0.0)

通过上面的代码，不难总结出：对于数值类型，所有的非零值转换为True, 只有零值才转换为False.

字符串也可以转换为布尔值

# 这是一个空字符串，转换结果为False
bool("")
# 转换结果为True
bool("abc")
# 这是一个只包含一个空格的字符串，转换结果为为True
bool(" ")

对于任何非空的字符串，转换为布尔值都是True。注意第一行代码和第三行代码

空值转换为布尔值永远都是False（敲黑板）

# 结果为False
bool(None)

 

2.2.5.2 字符串转换     

首先介绍一下我们可以使用str() 将其他类型转换为字符串，

True, False, None 这三个值转换为字符串就是它们的单词本身，实际上在实际编程中，我们很少需要把它们转换成字符串来使用。

str(True) # 结果是'True'
str(False) # 结果是'False'
str(None) # 结果是'None'

对于数值类型，我们也可以用str()将它们转换为字符串，

print("My age is", str(18))

在上面的例子中，我们使用str()将18转换为"18"，然后再输出。实际上，在这个例子中，如果不进行强制转换的话，也不会出错，那是因为，print函数会自动将数值先转换成字符串再输出。

 

2.2.5.3 数值转换 

数值转换是我们在数据分析过程中经常用到的，因为我们从任何文件中读到的数字一开始都是字符串，需要将它们转换为数值才能进行运算。

如果想要把一个整数字符串转换为int类型，使用int()；

num = "1"
int(num) + 1

如果将int()去掉，这段代码则会报错，因为num是个字符串，不能将字符串和数值进行相加。

数值的前后带有空格也可以成功转换

int(" 100 ") # 结果为100

带有符号的数字也可以成功转换

int("-1") # 结果为-1
int("+1") # 结果为1

如果想要把一个带小数点的字符串转换为float类型，使用float()

pi = "3.1415926"
float(pi)

int类型和float类型之间也可以相互转换

int(3.14) #结果为3
int(9.9) # 结果为9
float(100) # 结果为100.0

注意第二行中，9.9并没有转换为10，虽然这样更符合我们的常识，四舍五入嘛，但float在被转换为int 的过程中，它的小数部分精度将被丢弃，只取整数部分。所以在将float转换为int的过程中，永远要小心。

那如果想要四舍五入的来转换呢，毕竟这样更符合我们的需求。Python给我们提供了一个内置函数： round

round(9.9) #结果为10
round(9.5) #结果为10
round(9.49) #结果为9

甚至，round函数让我们可以指定要保留小数点后几位：

# 保留小数点后两位，由于第三位是1，所以结果是3.14
round(3.1415926, 2)
# 保留小数点后三位，由于第四位是5，所以结果是3.142
round(3.1415926, 3)

布尔值也可以转换为int或者float

int(True) # 结果是1
int(False) # 结果是0
float(True) # 结果是1.0
float(False)# 结果是0.0

观察一下，恰好是数值类型转换为布尔类型的相反过程。

 

第三节 运算符 

2.3.1 算术运算符

Python中进行数值运算需要的符号如下，我们来一一学习一下。

运算符	描述	实例
+	加	1 + 1; a + b
-	减	10 - 5; a - b -c
*	乘	4 * 2 相当 4 × 2
/	除	4 / 2 相当于 4 ÷ 2
//	取整除	10 // 4 结果是 2
%	取模	10 % 4 相当于 10 - (10 // 4) × 4
**	指数	2 ** 3 相当于 2 * 2 * 2，也就是2的3次方
()	小括号	提高运算优先级，比如: (2 + 8) * 3

我们来看几个例子：

print(1 + 1)
print(10 - 5)
print(4 * 2)
print(4 / 2) # 结果是2.0

上面的例子都是简单的加减乘除，我们用肉眼就能观察出结果，需要注意的是除法运算, 当我们使用单斜杠除法运算符时，即使除数和被除数都是整数，它的返回结果也是一个浮点数。

print(5 / 2) # 结果是2.5
print(5 // 2) # 结果是2

当我们需要对两个整数进行除法运算，且对结果的小数精度要求不高的时候，一般使用双斜杠来进行运算，这样能保证结果也是整数，不用再进行类型转换。

print(10 / 3) # 结果是3.3333333333333335、

上面这行代码的结果很有意思，我们都清楚，10 ÷ 3的结果是3.333...无限循环小数，但无限循环小数毕竟是个数学概念，计算机无法表达，所以只能显示到一定的位数。细心的你可能会发现 后一位为什么是5呢？四舍五入的话也应该是3呀。这是因为小数以二进制形式表示时的有穷性导致的，也就是计算机底层机制的原因。这里面的细节大家可以先不管，但要记住进行浮点数运算时是有精度问题的。

注意:在上面的代码里，所有的运算符两边都有一个空格，这是Python代码的书写规范。

print(10 % 4) # 结果是2
print((2 + 8) * 3) # 结果是30

取模运算符大家先暂时可以理解为取余数，记住以下几个规则：

• 当两个数能整除时，取模运算的结果为0，比如 8 % 4 的结果是0
• 当0
• 当两个数中有负数时，结果可能会跟我们预料的不同，记住这个公式就行了 ：a % b 就相当于a - (a // b) * b

最后，提醒一下，0不能作为除数，也不能用来取模。

 

2.3.2 使用算术运算符操作字符串  

字符串在Python中也可以“运算”，有两种操作，我们先看看加法。

print("Hello " + "world")

加号可以将两个字符串拼接成一个字符串，也可以将多个字符串拼接在一起：

print("apple " + "apple " + "apple ")

那如果有太多的"apple"怎么办呢？总不能一直加下去吧，这时候我们可以使用"*"运算符，表示将该字符串重复几次并拼接成一个字符串。

print("apple " * 5)

使用加号拼接字符串时需要注意，不能将字符串与数值一起相加，比如说我们要给用户发现一条查询积分的消息：

print("您账户积分为：" + 500)

这样写将会报错，所以我们要在拼接之前，先将500转换为字符串，运用我们上面学过的知识，修改成这样：

print("您账户积分为：" + str(500))

 

2.3.3 赋值运算符  

赋值操作其实我们已经用过了，在前面定义变量的时候我们都会使用等于号。

num = 1
name = "Smith"

结合上面的运算符，我们可以做更多的赋值操作：

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a

我们在日常编程中 常用的是加法赋值和减法赋值，比如设置一个计数器，每次+1

count = 0
count += 1
count += 1

执行了两次加法赋值操作后，count的值变成了2

 

2.3.4 比较运算符  

比较运算符是用来运算布尔值的， 将两个值放在一起比较， 后得到True或者False。

运算符	描述	实例
==	等于	100 == 100
!=	不等于	100 != 99
>	大于	2 > 1
<	小于	1 < 2
>=	大于等于	3 >= 2
<=	小于等于	2 <= 3

我们可以在控制台里输入一些比较运算，看看它们的返回值是什么

100 == 100 # True
100 == "abc" # False
1 != 2 # True
2 != 2 # False
3 > 3 # False
3 >= 3 # True
2 < 3 # True
2 <= 3 # True

这都是符合我们的常识的操作，大家在控制台里试着敲一遍就明白了。下面再试试一些比较特殊的例子：

100 == "100" # False
100 == 50 * 2 # True
str(100) == "100" # True
1.0 != 1 # False
int(1.9) == 1 # True

需要注意的一点是，数值100 和字符串"100"是不相等的，这一点尤其要小心，这种隐藏的bug很难被发现。

 

2.3.4 逻辑运算符  

真实的程序中，常常需要判断的条件是复杂的，所以我们需要逻辑运算符将多个比较运算连接起来。

运算符	逻辑表达式	描述
and	x and y	任意一个是False，结果就是False	True and False 结果为False
or	x or y	任意一个是True，结果就是True;	True or False 结果为True
not	not x	将条件取反	not False 结果为True

我们来看几个例子：

# 定义两个变量
a, b = 1, 2
a > 0 and a < b # True
a % 2 == 0 or b % 2 == 0 # True
not a > b # True

and, or, not 它们也是Python中的关键字，这是经常需要使用的三个关键字。掌握好逻辑运算符是学好任何一门编程语言的基础。

逻辑运算符可以与赋值操作组合，让你的代码更老练：

a = 0 or 100 # a=100
b = 1 or 2 # b=1

 

第四节 流程控制   

 经过前面三个小节的学习，我们已经对Python编程语言有了一个初步的了解。如果说Python是一条蟒蛇，变量、数据类型、运算符就是它的肌肉和骨架，而流程控制相当于它的神经系统，掌握了流程控制知识，就可以让Python灵活的游动起来。

Python的流程控制比较简洁，主要分为两块：条件判断和循环控制。

 

2.4.1 条件判断

2.4.1.1 if...else...语句  

在这里要介绍两个重要的关键字，if 和 else，看它们的字面意思就能猜到它们表示“如果”...  “否则”... 我们来看看在代码中如何使用

num = 3
# 通过取模运算判断num是否能被2整除
if num % 2 == 0:
    print(str(num) + "是一个偶数")
else:
    print(str(num) + "是一个奇数")

注意两条print语句前面的缩进

这一波段代码是一个完整的逻辑，今后我们写的程序会更复杂，但也只不过是这段代码的重复和组合而已。

 

2.4.1.2 elif    

上面的例子中是一个非常简单的逻辑，一个整数，它要么是偶数要么是奇数，如果说再复杂一点的条件，我们该如何写呢？比如说来判断一个学生的考试成绩，60分以下的为不及格，60~90分为合格，90 分以上为优秀，这里面有三个条件。

score = 59
if score < 60:
    print("您的考试成绩不及格")
elif score < 90:
    print("您的考试成绩合格")
else:
    print("您的考试成绩优秀")

在这个例子中，使用了一个新的关键字"elif",  它只能用在if判断之后，else之前。

 

2.4.1.3 if 条件嵌套

还是以学生考试成绩的例子来说，现在我们想对60~100分的进行更细的划分，60~70分为合格，70~90 分为良好，90分以上为优秀。

score = 100
if score >= 60:
    if score < 70:
        print("您的考试成绩为合格")
    elif score < 90:
        print("您的考试成绩为良好")
    else:
        print("您的考试成绩为优秀")
else:
    print("您的考试成绩不及格")

嵌套循环可以嵌套无数层，但通常我们都建议尽量减少嵌套的层数，以增加代码的可读性。

 

2.4.1.4 与逻辑运算符组合

age = 22
if age > 18 and age < 60:
    print("你已经不是个孩子啦，该去工作啦")

上面的例子表示，年龄大于18岁并且小于60岁，也可以这样写：

age = 22
if 18 < age < 60:
    print("你已经不是个孩子啦，该去工作啦")

这样的代码更简洁，可读性更高，这是Python特有的简洁写法。

 

2.4.1.5 自动类型转换  

if 和 elif 的后面总是跟着一个表达式，这个表达式的结果必须是True或者False，如果表达式运算出来的结果不是一个布尔值，则会自动将结果转换为布尔值，无论它是什么类型的值。转换的结果遵循我们之前学过的布尔转换规律。

count = 0
if count:
    print("条件成立")
else:
    print("条件不成立")

试着将count的值改为1，条件则成立了。

思考：如果改成负数呢？

result = None
if result:
    pass
else:
    print("什么收获都没有")

记住：0值、None 和空字符串转换为布尔值后都是False   

pass是Python的关键字，它表示什么也不做。

 

2.4.2 循环 

看到循环我们首先会想到一些物体，比如旋转的风扇、车轮，一个圆的形状。一个圆形的跑道，如果沿着它跑，除非我们自己停下来，永远不会有终点，但是可以计算我们跑了多少圈。假设我们在跑步之前，给自己设定一个目标，跑完10圈就不跑了，然后去一圈一圈的跑完了10圈，停止。这个过程就很像代码里的循环语句了。

2.4.2.1 while循环       

lap = 0
while lap < 10:
    lap += 1
    print("我跑完了第" + str(lap + 1) + "圈")

运行上面的代码，会得到以下的输出

 

2.4.2.2 for循环

for循环可以用来遍历序列，序列指的是一个可迭代的有序的集合，比如字符串就是一个序列，下面我们用for循环来打印出一个字符串中的所有字符。

seq = "hello"
for s in seq:
    print(s)

这段代码的输出如下：

h

e

l

l

o

也可以用for循环来打印一连串的数字，这里需要用到一个新的内置函数：range。

for i in range(5):
    print(i)

range函数的作用就是提供一个从0到4的迭代器，而for可以遍历这个迭代器。注意是从0开始的，整个循环一共打印了5个数。

输出结果是：

0

1

2

3

4

我们可以修改一下之前写的跑圈的while循环，改用for循环加range函数来实现：

for lap in range(10):
    print("我跑完了第" + str(lap + 1) + "圈")

对比一下，哪种写法更简洁，更优雅 ？很明显是用for循环这种。这里面有一个细节需要注意，由于lap 的值是从0开始到9结束，所以我们需要在输出的时候给它+1。

 

2.4.2.3 嵌套循环 

既然掌握了两种循环写法，那可以把它们组合起来运用，我们来写一个例子，在控制台中打印出指定边长的长方形或者正方形图案。

# 指定长方形的宽和高
width, height = 10, 5
# 因为是从上往下开始打印，所以先遍历高度
for i in range(height):
    for j in range(width):
        print("*", end="")
    print()

在这里，print函数有了第二个参数，end表示在打印完指定的内容后，在结尾再打印一个指定的字符串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再添加任何输出内容。

第二个print函数没有任何参数，那它会输出一个换行符。

所以整个程序的逻辑就是每输出10个星号后，输出一个换行符， 终输出的图案如下：

**********
**********
**********
**********
**********

 

既然可以打印出一个长方形，那我们也可以打印一个直角三角形：

*
**
***
****
*****

代码如下

for i in range(5):
    for j in range(i + 1):
        print("*", end="")
    print()

 

再来一个稍微复杂一点的案例，打印出这样一个九九乘法表：

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

代码如下

for i in range(1, 10):
    for j in range(1, i + 1):
        print("%s*%s=%s" % (j, i, i * j), end=" ")
    print()

 

2.4.2.4 break和continue

有时候在循环内部，我们需要临时略过某一次循环或者干脆跳出整个循环，这时候就需要用到break和 continue。

在下面这个例子中，我们使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们的和。

total = 0
for i in range(10):
    if i % 2 == 0:
        continue
    print(i, end=" + ")
    total += i
print(" = %s" % total)

关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打印出小数的整数部分。

s = "238.9237834829"
for i in s:
    if i == '.':
        print()
        break
    print(i, end='')

小数的整数部分都在小数点的左边，而我们遍历字符串是从左往右，所以当遇到小数点后，就停止遍历，这样就正好实现了打印这个小数的整数部分。

 

2.4.3 演示：智能密码锁程序               

近几年很流行的智能密码锁程序，除了可以用指纹开锁、人脸识别开锁外，都会有密码开锁的功能，以防万一。密码开锁功能是这样的，首先设定好密码，以后每次开锁的时候只要输入的数字中含有设定的密码，就视为解锁成功。这样的设定是为了防止别人的窥探，具有更高的安全性。

首先，由于涉及到了输入，先来学习一下Python内置的输入函数: input

password = input("请设置您的密码")

在执行到这行代码时，控制台就变成光标闪烁的状态，用户可以用键盘进行字符的输入，输入完成后，再输入一个回车表示输入结束，输入的字符串赋给等号左边的变量。

# 设置初始密码
password = "123"
while True:
    pwd = input("请输入您想要设置的密码：")
    # 如果没有输入任何密码，则使用初始密码作为密码
    if not pwd:
        break
    confirm_password = input("请再次输入您的密码：")
    if pwd == confirm_password:
        password = pwd
        break
    else:
        print("您两次输入的密码不一致，请重新输入。")
print("您的初始密码已设置为：" + password)
print("进入开锁程序。。。")
# 开锁
while True:
    input_pwd = input("请输入您的密码：")
    # 判断输入的密码中是否包含密码
    if password in input_pwd:
        print("开锁成功！")
        break
    else:
        print("您输入的密码有误，请重新输入")

注意 password in input_pwd 这行代码，关键字in表示如果在指定的序列中找到值返回 True，否则返 回 False。