Python基础

第一章 Python分支结构

1.1 无输入

1.1.1 Python 变量和常量以及它们的命名规则

变量

在了解 Python 的变量之前，我们首先需要明白什么是变量。假设现在我们有以下 Python 代码：

variable = 1

其中=表示的是赋值运算符，每个变量需要先赋值再使用，变量在被赋值之后才会被创建。=前面表示的就是变量，variable 表示的就是变量名称，1 表示的是变量的值。在程序运行过程中，变量的值一般都会发生改变，内存中会专门开辟一段空间，用来存放变量的值，而变量名将指向这个值所在的内存空间，如图1所示。

图1

Python 中大小写是敏感的，所以 variable 和 VARIABLE 是两个不同的变量。

命名规范

变量是标识符的一种，而变量的命名规范也就是标识符的命名规范。 在选择标识符时，我们需要注意以下几点：

• 标识符只能是字母、数字或下划线的任意组合；

• 标识符的第一个字符不能是数字； 以下都是合法变量名：

  variable_a       _variable        a_variable_1

  以下都是非法变量名：

  1variable        var?iable        vari\able

• 以下关键字不能声明为变量名：

  关键字是Python语言已经定义好、具有特定含义的标识符，不允许开发者自己定义和关键字名字相同的标识符。

  'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield'

常量

与变量相对的就是常量，在程序运行过程中，常量的值不会发生改变。但是在 Python 中没有专门定义常量的语法。

整型常量示例：1，5，-10 浮点型常量示例：1.5，2.3014，-10.55

1.1.2 代码注释

代码注释分为单行注释和多行注释，单行注释通过 # 实现，而多行注释通过 '''...'''或者"""..."""实现。在代码运行过程中，会跳过注释部分。具体实现如下列代码所示：

# 这是单行注释
"""这是多行注释这是多行注释"""

1.1.3 整型和浮点型数据

在 Python 中定义变量的时候，我们通常需要给变量赋值，而这个值也分为不同的类型，下方我们介绍了其中的整形和浮点型：

• 整型（int）

  int_num = 1      # 将整型常量 1 赋值给变量 int_num

• 浮点型（float）

  float_num = 0.5      # 将浮点型常量 0.5 赋值给变量 float_num

1.1.4 算术表达式

在代码中我们经常需要用到一些基本的算术运算，下面我们通过一个表格来给大家介绍 Python 中的常用运算符。

下表中 a = 10，b = 21，x = 5.2，y = 2.5

基本算术运算符表

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31 x + y 输出结果 7.7
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11 x - y 输出结果 2.7
*	乘 - 两个数相乘	a * b 输出结果 210 x * y 输出结果 13.0
/	除 - x 除以 y	b / a 输出结果 2.1 x / y 输出结果 2.08
%	取余 - 返回除法的余数	b % a 输出结果 10 y % x 输出结果 2.5
**	幂 - 返回 x 的 y 次幂	ab 为 10 的 21 次方 xy 为 5.2 的 2.5 次方
//	整除 - 向下取接近商的整数	9 // 2 的结果为 4 5.2 // 2.5 的结果为 2.0

1.1.5 打印输出

在 Python 中，如果我们想将结果输出到控制台（控制台是一个用来提供字符输入或者输出的接口），我们可以使用 print 函数来实现，使用方法如下列代码所示：

a = 1      # 将整型常量 1 赋值给变量 a
b = 2.5      # 将浮点型常量 2.5 赋值给变量 b
print(a)        # 输出变量 a 的值
print(b)        # 输出变量 b 的值

输出：

1
2.5

1.2 有输入格式

1.2.1 字符串类型的基本使用

在上一个学习类型的实训中，我们介绍了 Python 的整型和浮点型，而本实训介绍的是 Python 中最常用的数据类型 —— 字符串类型。

我们可以使用引号( ‘ 或 “ )来创建字符串，如下列代码所示。

string = "hello world"      # "hello world"是一个字符串常量，将其赋给字符串变量str

字符串也可以进行特定的加法和特定的乘法运算：

str1 = "abc"          # 定义一个字符串变量str1，值为"abc"
str2 = "def"          # 定义一个字符串变量str2，值为"def"
​
# 加法运算：只能进行字符串与字符串的加法
add_result = str1 + str2      # 将str2的字符串拼接到str1后面，将得到的新字符串赋值给add_result
print(add_result)  
​
# 这一步的输出为 "abcdef"
# 乘法运算：只能进行字符串与整型数据的乘法
mul_result = str1 * 3       # 将str1的字符串复制两份，将复制的两份拼接在str1后面
print(mul_result)     # 这一步的输出为 "abcabcabc"

小贴士：将 str1 字符串乘以 2 等价于 str1 + str1。

1.2.2 数据类型转换

Python 中不同的数据类型可以进行转换，我们之前介绍过整型、浮点型和字符串三种数据类型，下面我们通过代码来了解如何进行数据类型转换。

• 整型转换为浮点型和字符串

  # 定义一个整型变量 int_num，值为1
  int_num = 1
  # 使用 float 函数将 int_num 转换为浮点型，并赋值给 float_num
  float_num = float(int_num)
  print(float_num)     # 输出的值为 1.0# 使用 str 函数将 int_num 转换为字符串，并赋值给 str_num
  str_num = str(int_num)
  print(str_num)        # 输出的值为 "1"

• 浮点型转换为整型和字符串

  # 定义一个浮点型变量 float_num，值为2.8
  float_num = 2.8
  
  # 使用 int 函数将 float_num 转换为整型，并赋值给 int_num
  int_num = int(float_num)
  print(int_num)          # 输出的值为 2
  
  # 使用 str 函数将 float_num 转换为字符串，并赋值给 str_num
  str_num = str(int_num)
  print(str_num)        # 输出的值为 "2.8"

• 字符串转换为整型和浮点型

字符串转换为整型和浮点型时，只有字符串值为数字时才能转换，否则代码运行时将报错。

# 定义一个字符串变量 str_num，值为"2.1"
str_num = "2.1"    # 如果 str_num = "abc"，则下列代码会报错# 使用 int 函数将 str_num 转换为整型，并赋值给 int_num
int_num = int(str_num)print(int_num)      #输出的值为 2# 使用 float 函数将 str_num 转换为浮点型，并赋值给 float_num
float_num = float(str_num)
print(float_num)       # 输出的值为 2.1

Python 中自带了一个可以查看数据类型的函数 type，它的使用方法如下。

int_num = 1              # 定义一个整型变量int_num，值为1

# 使用type函数查看int_num的数据类型，并将函数的返回结果赋值给type_value
type_value = type(int_num)
print(type_value)

输出：

<class 'int'>

1.2.3 input 的使用

当我们想要从键盘获取某个值时，我们可以使用 input 函数来实现，input 函数得到的值默认是字符串类型，如下图 1 的 gif 所示。

如果我们需要使用 input 函数获取非字符串类型的数据，例如整型、浮点型数据，则需要对获取的字符串类型的数据进行数据类型转换。

图 1

1.2.4 print 的格式化输出

在之前的学习类型实训中，我们简单介绍了 print 函数的基本使用，假设我们想要输出更清晰的信息，例如“正方形的面积为100平方米。”，就可以使用 print 函数的格式化输出方式。

我们通过几个个简单的例子来介绍格式化输出的方式。

area = 10     # 定义一个变量area， 值为 10
print("正方形的面积为%d平方米。"%  area)

上面的 print 语句中引号内的内容为一个待打印的字符串，其中 %d 是一个格式化符号，表示在此处打印一个整型数据，该数据的具体取值由引号右侧的百分号后面的数据决定，此语句中对应的是变量area的值。 输出：

正方形的面积为10平方米。

整型数据、浮点型数据和字符串对应的格式化符号分别是：%d、%f、%s

shape = "长方形"      # 定义一个字符串变量shape
area = 10     # 定义一个变量area， 值为 10
print("%s的面积为%d平方米。" % (shape,area))     # 其中shape对应的是%s，area对应的是%d

输出：

长方形的面积为10平方米。

如果在字符串中给的是 %d 和 %f，而传入 print 函数的值为字符串时，代码运行时则会报错。

shape = "长方形"      # 定义一个字符串变量shape
area = 2/3     # 定义一个变量area，表示长方形的面积
print("%s的面积为%f平方米。" % (shape,area))     # 其中shape对应的是%s，area对应的是%f

输出：

长方形的面积为0.666667平方米。

%f 会将结果四舍五入后保存到小数点后六位。

那假如我们只想要保留两位小数又该如何做呢？%.nf 可以设置小数点后保留的位数（n 表示保留的位数）：

shape = "长方形"      # 定义一个字符串变量shape
area = 2/3     # 定义一个变量area，表示长方形的面积
print("%s的面积为%.2f平方米。" % (shape,area))     # 其中shape对应的是%s，area对应的是%.2f，表示四舍五入后保留小数点后两位数字

输出：

长方形的面积为0.67平方米。

1.3 内置函数与数学函数

1.3.1 数学函数

模块的导入方法

导入模块是为了调用定义在其他文件中的变量、函数或者类（后面的实训会具体说明什么是类和函数）。Python 中内置了一个数学相关的模块，模块名为 math，本实训将通过该模块来介绍三种模块的导入方法。

import 语句

在之前的练习实训中，我们求平方根是通过x**0.5实现的，其实我们还可以通过调用 math 模块中的 sqrt 函数实现。

import math     # 导入Python的内置库math，并导入了该模块内的所有内容
num = 4
value = math.sqrt(num)     # 调用math模块中的sqrt函数对num的值求平方根
print(value)     # 结果为2

>小贴士：不管你执行多少次 import，一个模块只会被导入一次。

from … import * 语句

from ... import *语句也会将模块中的所有内容都导入到当前的空间，我们可以在当前代码文件中调用该模块的所有变量、函数和类，不用再写出模块名。

from math import *     # 导入math模块中的所有变量、函数和类
num = 4
num1 = pi     # pi是math模块中的数学常量，表示圆周率
value = sqrt(num)     # 调用math模块中的sqrt函数对num的值求平方根，不需要再写出模块名
print(value)     # 输出结果为2.0
print(num1)     # 输出结果为3.141592653589793

from … import 语句

上面个两种方法会导入模块中的所有内容，会非常占用内存，而from ... import这种方法，我们可以只导入模块中的一个或多个函数。我们同样以 math 模块为例子。

from math import sqrt     # 导入math中的sqrt函数，这样就只能调用sqrt方法
num = 4
value = sqrt(num)     # 调用math模块中的sqrt函数对num的值求平方根，不需要再写出模块名
print(value)     # 结果为2.0

常用数学函数

表 1 中介绍了 math 模块中常用的几个数学函数。

表 1 常用数学函数表（部分）

函数	使用说明
exp(x）	返回 ex
expm1(x)	返回 ex-1
log(x[,base])	返回 x 的以 base 为底的对数，base 默认为 e
log2(x)	返回 x 基数为 2 的对数。通常比log(x,2)更准确
log10(x)	返回 x 基数为 10 的对数。通常比 log(x,10) 更准确
pow(x,y)	返回 x 的 y 次方，即 x**y
sqrt(x)	返回 x 的平方根

1.3.2 内置函数

bin 函数

bin 函数是 Python 的内置函数（内置函数是 Python 自带的函数，不需要从其他模块导入）之一，它的作用是将整型数据转换为二进制数据。

num = 4
print(bin(num))     # 打印整型数字 4 的二进制形式型

输出：

0b100     # 0b表示二进制，100表示4的二进制形式

> 小贴士：bin 函数返回的是一个字符串，不能直接对返回值进行计算。

参数不仅可以接受十进制整数，八进制、十六进制也是可以的，只要是 int 型数据就合法。

num1 = bin(0b10010)     # 0b表示二进制，这一步是二进制转二进制，显然结果是不会变的
num2 = bin(0o10)     # 0o表示八进制
num3 = bin(0x2d)     # 0x表示十六进制
print(num1)
print(num2)
print(num3)

输出：

0b10010
0b1000
0b101101

oct 函数

oct 函数是将一个整型数据转换成八进制，它和 bin 函数的用法一致。

num = 10
print(oct(num))     # 打印整型数字 10 的八进制形式型

输出：

0o12     # 0o表示八进制，12表示10的八进制形式

参数也可以接受二进制整数、十六进制数，只要是 int 型数据就合法。

num1 = oct(0b10010)     # 0b表示二进制
num2 = oct(4)           # 4是十进制数
num3 = oct(0x2d9)       # 0x表示十六进制
print(num1)
print(num2)
print(num3)

输出：

0o22
0o4
0o1331

hex 函数

hex 函数是将一个整型数据转换成十六进制，它和 bin 函数的用法一致。

num = 10
print(hex(num))     # 打印整型数字 10 的十六进制形式型

输出：

0xa     # 0x表示十六进制，a表示10的十六进制形式

参数也可以接受二进制整数、八进制数，只要是 int 型数据就合法。

num1 = hex(0b10010)     # 0b表示二进制
num2 = hex(0o4)         # 0o表示八进制
num3 = hex(18)          # 18表示十进制数
print(num1)
print(num2)
print(num3)

输出：

0x12
0x4
0x12

int 函数

在之前的实训中，我们了解到 int 函数可以将部分非整型的数据转换为整型，除此之外，它还可以在传一个参数来表示进制数。

num1 = int("0b1101", 2)     # “0b1101”表示字符串，当传入参数2时，字符串的内容就会转换成二进制，如果无法转换成二进制，则代码运行时报错
num2 = int("0o11", 8)     # 转换成八进制
num3 = int("0x2b", 16)     # 转换成十六进制
print(num1)
print(num2)
print(num3)

代码运行结果：

13
9
43

返回的结果都是十进制数。 在了解了 int 函数的第二个参数后，我们就可以结合 input 函数来获取不同进制数了。如图 1 所示。

图1

第二章 Python分支结构

2.1 单路分支

2.1.1 布尔类型

布尔类型是 Python 的基本数据类型之一，布尔类型的数据常量只有 True 和 False，分别表示真和假。Python 中定义了一个 bool 函数来将其他数据类型的数据转换成布尔型。

num1 = 0
num2 = 2
print(bool(num1))     # 打印num1的布尔值
print(bool(num2))     # 打印num2的布尔值

代码运行结果：

False
True

在整型和浮点型数据中，只有数据值为 0 时，转换成布尔类型才会是 False，其它值的转换结果都是 True 。

当数据类型为字符串时：

str1 = ""     # 定义了一个空字符串
str2 = "hello world"
print(bool(str1))
print(bool(str2))

代码运行结果：

False
True

只有字符串为空时，布尔值才会为 False，否则都为 True。

2.1.2 关系运算符

关系运算符，顾名思义是用来比较两个值的关系的运算符。

我们以表格的形式来详细介绍关系运算符，假设表格中的a = 10 ，b = 20，x 和 y 表示任意两个数值。

表 1 关系运算符表

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回 x 是否大于 y	(a > b) 返回 False。
<	小于 - 返回 x 是否小于 y。	(a < b) 返回 True。
>=	大于等于 - 返回 x 是否大于等于 y。	(a >= b) 返回 False。
<=	小于等于 - 返回 x 是否小于等于 y。	(a <= b) 返回 True。

>小贴士：所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意这些变量名首字母大写。

之前的学习中，我们了解了赋值运算符、算术运算符和关系运算符，当一个执行语句中，同时有这三个运算符时，它们的优先级为算术运算符>关系运算符>赋值运算符。

2.1.3 单路分支结构 if

假设我们现在要让计算机判断一个整型数值是正数还是负数，该怎么编写代码实现呢？这时我们就可以使用 Python 中的单路分支结构 if 语句。语句格式如下：

if 表达式：    
	执行语句

if 语句的运行流程图如下图 1。

图1

已知 i 为 -1，如果 i 小于 0，则输出 “i为负数”，否则直接结束。

代码实现如下：

i = -1
# i<0是通过关系运算符得到的一个布尔类型的值，if语句后要以英文冒号结尾
if i < 0:     # 判断语句为True时才会运行的代码   
    print("i 为负数")     # if 语句内的代码需要进行缩进操作，也就是代码最前方要有4个空格

# i<0返回的结果是False，所以这个if语句内的代码不运行
if i < 0:    
    print("i 为正数")

代码运行结果：

i 为负数

如果我们想在周末天气好的时候出去玩，那么我们应该怎么来通过代码判断呢？这时就可以使用 if 语句进行多重嵌套，如以下代码所示。

if today == "周末":    
	if weather == "晴天":     # 每一个if之后都要进行一次缩进操作        
		print("出去玩")            
        ...

>小贴士：if 后的表达式可直接为整型、浮点型和字符串类型的数据。

2.2 双路分支

2.2.1 双路分支结构if-else

在上一个学习类型的实训中，我们介绍了单路分支结构的 if 语句。但是单路分支结构的 if 语句在判断某个数是否为正数时，要用到两个 if 语句，非常的不方便。双路分支结构 if-else 就能完美的解决这个问题。if-else 的语句格式如下：

if 表达式:    
	执行语句1
else:    
	执行语句2

双路分支结构 if-else 的流程图如图 1 所示。

图 1

已知 i 为 -1，如果 i 小于 0，则输出 “i为负数”，如果 i 不小于 0，则输出“i不是负数”。 代码实现：

i = -1
if i > 0:    
	print("i为负数")
else:   
	print("i不是负数")

执行结果：

i不是负数

这段代码通俗易懂的解释为：如果 i 大于 0，则输出”i为负数”，否则输出”i不是负数”。

2.2.1 逻辑运算符

Python 中的逻辑运算符有三个，如表 1 所示（其中的a=10，b=20）。

表 1 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

三种逻辑运算符的真值表如表 2 所示：

表 2 真值表（1 为 True，0 为 False）

x	y	x and y	x or y	not x	not y
0	0	0	0	1	1
1	1	1	1	0	0
1	0	0	1	0	1
0	1	0	1	1	0

2.3 多路分支

2.3.1 多路分支结构 if-elif-else

当我们想判断一个数是正数或负数还是 0 时，普通的单路分支要写两次 if-else ，非常麻烦，这时我们就可以使用多路分支结构，与双路分支结构 if-else 相比，多路分支结构多出了 elif，接下来我们通过代码来理解多路分支结构 if-elif-else 的作用。 if-elif-else 的用法：

if 表达式A:    
	print("A成立")
elif 表达式B:     # 如果条件A不成立，则运行elif内的代码    
	print("B成立")
else:     # 如果条件A和B都不成立，则运行else内的代码    
	print("C成立")

这段代码的解释为：如果条件 A 成立，那么输出“A成立”；如果条件 B 成立，那么输出“B成立”，否则输出“C成立”。

实际应用：

num = 1
if num > 0:    
	print("num为正数")
elif num < 0:   
	print("num为负数")
else:    
	print("num为0")

代码运行结果：

num为正数

多路分支的优点在于它能使用多个 elif，如下列代码所示。

if 条件A:    
	···
elif 条件B:   
	···
elif 条件C:   
	···
···
else:    
	···

第三章 Python循环结构

3.1 while循环

3.1.1 while 循环

在之前的实训中，我们学习过 input 函数，我们可以使用它从键盘获取一次字符串值，假如我们要获取 100 次值时，难道要写 100 次 input 语句吗？这时我们就可以使用 while 循环。while 循环就是只要条件满足，就不断循环，条件不满足时退出循环。它的语句格式如下：

while 表达式:     # 这个表达式结果必须是布尔类型或者能够转换为布尔类型    
	执行语句1    
	执行语句2      
	···

while 循环的流程图如下图 1：

图1

当我们要获取 100 次键盘输入的值时，我们可以使用以下代码：

i = 0
while i < 100:     # 如果i的值小于100则执行循环内的语句    
    input()    
    i += 1

假设我们要计算 100 以内所有奇数之和，具体代码实现如下：

sum = 0
n = 99
while n > 0:      # 当n>0时，则执行while循环内的语句    
    sum = sum + n    
    n = n - 2
print(sum)

代码运行结果：

2500

while 循环注意事项：while 循环在给定表达式后，执行语句中必须给出能改变表达式结果的语句，否则 while 循环将进入死循环。我们通过代码来了解什么是无限循环。

i = 1
while i < 10:    
    print("i=%s" % i)

上面代码的表达式为i<10，但是执行语句中，并没有改变表达式结果的语句。所以这个 while 语句进入了死循环。想要避免死循环，在 while 循环中必须改变 i 的值。

i = 1
while i < 10:    
    print("i=%s" % i)    
    i += 1     # 等价于i = i+1

执行结果：

i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

在 Python 中，循环结构也是可以嵌套的。但是我们使用 while 嵌套循环时，需要注意避免无限循环的情况出现。

while 表达式:    
	执行语句    
	while 表达式:        
		执行语句       
	···

代码实现:

i = 1
while i < 4:    
	n = 1    
	while n < 3:        
		print("第二层循环")        
		n += 1    
	print("第一层循环")    
	i += 1

执行结果：

第二层循环
第二层循环
第一层循环
第二层循环
第二层循环
第一层循环
第二层循环
第二层循环
第一层循环

3.2 for循环

3.2.1 列表的基本概念

列表是最常用的 Python 数据类型之一。列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项，使用方括号[]括起来即可。 简单来说，列表是由一系列元素，按特定顺序排列组成。你可以创建包含字母表中所有字母、数字或一些字符串的列表；还可以将其他数据类型放入列表中，甚至可以将另一个列表放在列表中。

list1 = [1, 2, 3, 4]     # 创建了一个列表，列表里的元素全部都为整型
list2 = [1, 2.5, "a", "hello", [1, "b"], True]     # 列表里的元素可以为任意类型

print(type(list1))     # 打印list1的类型
print(list1)
print(list2)

执行结果：

<class 'list'>
[1, 2, 3, 4]
[1, 2.5, 'a', 'hello', [1, 'b'], True]

访问列表内元素的方法和访问字符串的方式一样，都是通过下标来确定访问元素的位置。

list2 = [1, 2.5, "a", "hello", [1, "b"], True]
value1 = list2[0]
value2 = list2[4]
print(value1)
print(value2)

执行结果：

1
[1, 'b']

在之前学习的 len 函数也可以将列表作为参数，len 函数返回的是列表内的元素个数。

list2 = [1, 2.5, "a", "hello", [1, "b"], True]
print(len(list2))

执行结果：

6

Python 中有一个类型转换函数 list，它可以将部分其他类型的数据转换为列表，例如字符串以及后面将学习到的元组，集合。

string = "hello"
result = list(string)
print(result)

执行结果：

['h', 'e', 'l', 'l', 'o']

3.2.2 range 函数的使用

range 函数可创建一个有序的整数序列。range 函数有三个参数：range([start,] stop[, step])，方括号内[]的内容表示可以省略，其中 start 表示有序序列开始的数，它是可以省略的，当不传 start 值时，它默认为 0，stop 表示结束的数（结束的值取不到，等价于区间的左闭右开），step 表示步长，step 参数的默认值为 1。

reslut = range(5)     # range(5)的取值结果为一个0-4的有序序列
print(result)

执行结果：

<class 'range'>

可以看到 range 函数返回的并不是一个列表，当我们想查看 range 返回的有序序列时，不能直接使用赋值语句将它的返回结果赋给一个变量。如果我们想要查看 range 的结果，则需要用到类型转换函数 list 将其转换为列表。

# 传入一个参数
result1 = list(range(5))     # 取0-4的有序序列，等价于range(0, 5)
# 传入两个参数
result2 = list(range(1,5))     # 取1-4的有序序列# 传入三个参数
result3 = list(range(1, 5, 2))     # 取1-4的有序序列，步长为2
print(result1)
print(result2)
print(result3)

执行结果：

[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 3]

3.2.3 for 循环语句

Python 的 for 语句格式如下所示，它将依次调取序列中的元素并将其分配给变量，然后执行一遍循环体中的所有执行语句，直到整个序列中的元素取完为止。

for 变量 in 序列:    
	执行语句    
	···

for 循环的流程图如图 1 所示。

图 1

for 循环会依次遍历序列中的成员，执行循环语句。例如：

list1 = ['python','java','c','c++']
for book in list:    
	print("当前书籍为:%s" % book)

执行结果：

当前书籍为:python
当前书籍为:java
当前书籍为:c
当前书籍为:c++

Python 中的 for 循环通常与 range 函数连用。

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

执行结果：

0
1
2
3
4

for 循环还有一些常用的小技巧。举个例子：

list1 = ['python','java','c','c++']
list2 = ['mysql','php','R','golang']
# len(list1)返回的是列表的长度，等价于range(4)
for book in range(len(list1)):    
	print(list2[book])

执行结果：

mysql
php
R
golang

3.3 break与continue

3.3.1 break 语句

在之前学习 while 循环时，如果我们在执行语句中不改变表达式的结果，那么代码将进入无限循环；若是我们无法在执行语句中改变表达式结果呢？这时我们就可以使用 break 语句。break 语句是用于结束当前循环。

假设老师想求一个班上 5 名同学的平均成绩，分数都是通过 input 函数获取，分数的取值范围为 0-100，假设老师输入时不小心输入了一个超出范围的值，这时，我们就可以通过 break 语句来结束循环。

num = 0
sum_score = 0
while num < 5:    
	score = int(input())     # 每循环一次就输入一个值    
	if score < 0 or score > 100:     # 如果输入的分数小于0或大于100就退出循环        
		print("输入的数据不合法，请重新输入")        
		break    
	sum_score += score    
	if num == 4:     # num=4的时候表示分数都输入完成，可以计算平均分        
		mean_value = sum_score/5        
		print("平均成绩为",mean_value)    
		num += 1

输入数据1：

50
66
906
100
88

执行结果1：

输入的数据不合法，请重新输入

输入数据2：

50
66
90
100
88

执行结果2：

平均成绩为 78.8

当发生循环嵌套时，break 语句只能结束当前循环。

num = 1
while num < 4:    
	print("第一次循环")    # 正常情况下，表达式为True，第二层循环会无限循环，但是break语句让第二层循环只执行了一次    
	while True:        
		print("第二层循环")        
		break    
	num += 1

执行结果：

第一次循环
第二层循环
第一次循环
第二层循环
第一次循环
第二层循环

通过结果可以得知，break 每次都是结束当前的第二次循环，并没有结束它的上一级循环。

for 循环中也可以使用 break 语句，它也只能结束当前的 for 循环。

for x in range(5):    
	if x > 2:        
		break    
	print(x)

执行结果：

0
1
2

3.3.2 continue 语句

while 循环和 for 循环都可以使用 continue 语句，这个语句的作用是结束本次循环，重新开始下一次循环。 以下场景便模拟了 for 循环结构跳出当前循环的现实场景：

全班同学的试卷为一个序列，老师在批阅一个班同学的试卷时，需要从第一个同学开始一个一个批阅，然后根据每个同学的具体答卷情况给出最后得分。如果评阅到某张试卷时发现这位同学缺考，为空白卷，那么就不评阅这张试卷，直接评阅下一张。当全部同学的试卷都评阅完毕时，结束评阅，跳出循环。跳过评阅空白卷的过程就相当于使用了 continue 语句。

continue 语句与 break 语句使用方法一致，但是作用不同，continue 的基本形式为：

for 变量 in 序列:    
	执行语句    
	if 表达式：        
		continue

我们通过代码来实现上述场景，假设班上有 5 个同学，我们用 0 表示白卷：

student = [10, 50, 0, 62, 90]
for stu in student:    
	if stu == 0:     # 如果stu等于0，跳出本次循环        
		print("白卷")        
		continue    
	print("分数为%d"% stu)

执行结果：

分数为10
分数为50
白卷
分数为62
分数为90

continue 语句同样无法结束循环，只能跳过本次循环。

num = 0
while num < 10:    
    if num == 5:     # 如果num等于5，跳出本次循环        
        num += 1        
        continue    
    print(num)    
    num += 1

执行结果：

0
1
2
3
4
6
7
8
9

当发生循环嵌套时，continue 只会跳过当前循环，而不会影响其他层的循环。

for x in range(2):    
    for y in range(3):        
        if y == 2:            
            continue        
        print("第二次循环第%d次" % y)    
    print("第一次循环第%d次" % x)

执行结果：

第二次循环第0次
第二次循环第1次
第一次循环第0次
第二次循环第0次
第二次循环第1次
第一次循环第1次

从执行结果可以得知，第二层循环本来要运行 3 次，但是当 y 等于 2 时跳出了本次循环，但是并没有影响第一层循环。

注意：在 Python 中，break、continue不能直接使用，应和分支语句配合使用。

3.4 for...else

for-else 语句是 for 循环的一种，它和 break 语句一起使用时才能显示出 else 的作用。下面给出了两个使用 for-else 的例子及其执行结果。

for i in range(10):    
	if i == 5:        
		print( 'found it! i = %s' % i)
else:    
		print('not found it')

执行结果：

found it! i = 5
not found it

# 这段代码中，在i=5时使用了break结束了循环
for i in range(10):    
	if i == 5:        
		print( 'found it! i = %s' % i)        
		break
else:    
	print('not found it')

执行结果：

found it! i = 5

从上述两段代码的运行结果可知，第一段代码并没有使用 break 语句，循环是完整的进行完了的，所以 else 语句中的代码运行了，而在第二段代码中，在 i=5 时使用了 break 结束了循环，所以 else 语句中的代码并没有执行。可以发现，如果循环在运行过程中被中断，则 else 语句不会执行。

第四章 Python列表、元组、字典与集合

4.1 列表

4.1.1 更新列表元素

列表内的元素都是通过下标来取值的，如果我们想要更新列表的元素，首先需要定位到这元素的位置才能更改它的值。

list1 = [1,2,3,4,5]
list1[2] = 0     # 将list1的第3个值改为0
print(list1)

执行结果：

[1, 2, 0, 4, 5]