https://www.shiyanlou.com/courses/596/learning/

1.开启python之旅

实验介绍

本课程基于Python for you and me教程翻译制作，其中参考了Python tutorial和The Python Standard Library，并对原教程的内容进行了改进与补充。

相关链接地址如下：

• Python tutorial：http://www.pythondoc.com/pythontutorial3/index.html
• Python for you and me：http://pymbook.readthedocs.io/en/latest/
• The Python Standard Library：https://docs.python.org/3/library/index.html

Python for you and me的法律声明有如下内容：

Permission is granted to copy, distribute, and/or modify this document under the terms of the Open Publication Licence, Version 1.0, or any later version.

知识点

• 使用交互模式的 Python3 解释器
• 简单使用 vim 编写 Python3 脚本
• 执行 Python3 脚本
• Python3 代码风格建议
• Python3 中使用注释
• 认识 Python3 模块

实验环境

• Python 3.5
• Xfce 终端
• Vim

适合人群

本课程属于初级级别课程，不仅适用于那些有其它语言基础的同学，对没有编程经验的同学也非常友好。

• 如果你是第一次接触实验楼，花几分钟过一下这个课程可以帮助你适应实验楼用户的界面：新手指南之玩转实验楼
• 如果你是以前没有在使用过 Linux，这个课程会让你在实验中更得心应手：Linux 基础入门（新版）

解释器

Python 是一个脚本语言，你可以在 Python 解释器中直接写代码或者将代码写到一个文件里，然后执行这个文件（即脚本文件）。

首先，我们从使用解释器开始，打开 Xfce 终端，键入python3并回车。这个时候解释器便工作于交互模式。

作为我们第一个 Python 代码，我们将打印经典的 “Hello World!”，输入python3，如下所示：

>>> print("Hello World!")
Hello World!

欣赏完自己的杰作后，按Ctrl + D输入一个 EOF 字符来退出解释器，你也可以键入exit()来退出解释器。

脚本文件

作为正式的程序员，你可能想要将上述的代码写到一个源文件。那么我们来创建一个 helloworld.py 文件，用你喜欢的任何编辑器来创建这个文件，我使用 Vim ，你可以使用基于 GUI 的工具，如实验楼环境桌面上的 gedit。

我们建议使用 Vim，在这里我们简单的使用它，你可以在实验楼的课程Vim编辑器里深入学习或者通过这张vi(vim)键盘图帮助你记忆：

(原图来自：www.viemu.com)

首先，创建的文件会放在/home/shiyanlou目录下，打开 Xfce 终端，键入vim helloworld.py来启动 Vim 并编辑 helloworld.py，启动后不要乱按键。

然后按i键进入插入模式，此时你可以看到左下角有 “插入” 两个字，现在你可以键入下面的代码了。

#!/usr/bin/env python3
print("Hello World!")

其中第一行的前两个字符#!称为Shebang，目的是告诉 shell 使用 Python 解释器执行其下面的代码。

然后按Esc键退出插入模式，再键入:wq回车，Vim 就会保存文件并退出。

要运行脚本文件helloworld.py，还要为文件添加可执行权限（否则会出现权限不足的错误）：

$ chmod +x helloworld.py

在这里使用到了linux下的chmod命令来变更文件或目录的权限，+x代表赋予了其可执行的权限。
若想要了解更多，推荐你学习我们的Linux基础入门（新版）。
你也可以点击此处快速掌握常用 Unix/Linux 常用命令查看。

然后执行脚本文件：

$ ./helloworld.py

这里需要注意如果程序中没有#!/usr/bin/env python3的话，应该使用python3 helloworld.py来执行，否则使用./helloworld.py程序会被当作 bash 脚本来执行，最终报错。

代码风格建议

在 Python 中，空格很重要，我们使用空格将标识符区分开，行开始处的空格我们称之为缩进，如果你的缩进是错误的，Python 解释器会抛出错误。例如下面情形：

>>> a = 12
>>>   a = 12
  File "<stdin>", line 1
    a = 12
    ^
IndentationError: unexpected indent

这是因为第二行开始处出现了多余的空格，所以需要经常检查代码的缩进。
如果你在代码中混用制表符和空格，这种缩进错误会很常见。

所以如果是用空格，就一直用空格缩进，不要使用制表符。

建议遵守以下约定：

• 使用 4 个空格来缩进
• 永远不要混用空格和制表符
• 在函数之间空一行
• 在类之间空两行
• 字典，列表，元组以及参数列表中，在,后添加一个空格。对于字典，:后面也添加一个空格
• 在赋值运算符和比较运算符周围要有空格（参数列表中除外），但是括号里则不加空格：a = f(1, 2) + g(3, 4)

注释

注释是一些文本用来解释此处代码是做什么的，写注释是为了使他人更容易理解代码。

Python 的注释以#字符开始的，在#字符到行尾之间的所有东西都被程序忽略为注释，也就说对程序没有任何影响。

>>> # 这是一个注释
>>> # 下面这一行是求两数之和
>>> a = 12 + 34
>>> print(a) # 这里也是注释 :)

注释主要面向的人群是开发人员和维护代码库的人员，所以如果你写了一些复杂代码，你应该写足够的注释在里面，以便让其他任何人能够通过你的注释读懂代码。你应该总是在#后跟一个空格，然后再写注释。你也可以做一些标准的注释，像下面这样。

# FIXME -- fix these code later
# TODO -- in future you have to do this

模块

模块是包含了我们能复用的代码的文件，包含了不同的函数定义，变量。模块文件通常以 .py 为扩展名。

Python 本身在默认安装时就带有大量的模块。我们之后将会用到其中的一部分。在使用模块前先导入它。

>>> import math    # 导入math模块
>>> print(math.e)
2.71828182846

我们会在模块这个实验里学习更多有关模块的知识。

总结

完成本实验后，应当明白如何使用交互模式的 Python3 解释器，如何简单使用 vim 编写脚本文件并执行这个脚本文件。

要特别注意的是，Python 使用缩进来定义语句块，缩进是 Python 语法的一部分，这与其它大多数语言不同。

代码风格在本课程的实验PEP8 代码风格指南有更为详细的讲述。注释的话，能使用英文建议使用英文。模块同样会在之后的实验里深入学习。

2.变量和数据类型

实验介绍

本节实验内容主要包括 Python 基本的数据类型和变量。

知识点

• python 关键字
• 变量的定义与赋值
• input() 函数
• 字符串的格式化

关键字和标识符

每一种编程语言都有它们自己的语法规则，就像我们所说的外语。

下列的标识符是 Python3 的关键字，并且不能用于通常的标识符。关键字必须完全按照下面拼写：

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

这些内容可以在 Python3 解释器中得到：

在 Python 中 我们不需要为变量指定数据类型。所以你可以直接写出abc = 1，这样变量abc就是整数类型。如果你写出abc = 1.0，那么变量abc就是浮点类型。

>>> a = 13
>>> b = 23
>>> a + b
36

通过上面的例子你应该理解了如何在 Python 中定义变量，也就是只需要输入变量名和值就行了。Python 也能操作字符串，它们用单引号或双引号括起来，就像下面这样。

>>> 'ShiYanLou'
'ShiYanLou' 
>>> 'ShiYanLou\'s best' 
"ShiYanLou's best" 
>>> "Hello World!" 
'Hello World!'

从键盘读取输入

通常情况下，Python 的代码中是不需要从键盘读取输入的。不过我们还是可以在 Python 中使用函数input()来做到这一点，input()有一个用于打印在屏幕上的可选字符串参数，返回用户输入的字符串。

我们来写一个程序，它将会从键盘读取一个数字并且检查这个数字是否小于 100。这个程序名称是/home/shiyanlou/testhundred.py。还记得如何使用 Vim 吗？忘了的话可以看看下面的动图，打开 Xfce 终端，使用 Vim 开始编写代码：

在终端中输入：

$ vim testhundred.py

输入i后，编写以下代码：

#!/usr/bin/env python3
number = int(input("Enter an integer: "))
if number <= 100:
    print("Your number is less than or equal to 100")
else:
    print("Your number is greater than 100")

接着按ESC键并输入:wq退出Vim。
该段代码的含义如下：

如果number小于等于 100，输出 “Your number is less than or equal to 100”，如果大于 100，输出 “Your number is greater than 100”。

在执行程序前，别忘了为文件添加可执行权限：

$ chmod +x testhundred.py

程序运行起来就像这样:

$ ./testhundred.py
Enter an integer: 13
Your number is less than or equal to 100
$ ./testhundred.py
Enter an integer: 123
Your number is greater than 100

后续程序中将会用到之后实验将学到的 while 循环语句，这里先简单介绍下。
while 是使用一个表达式作为判断的条件，如果条件不能够达成则停止循环：

w = 20
while w > 1:
    print(w)
    w -= 1

这个循环中判断条件为w > 1，当条件不满足的时候就停止循环。当 w 的值小于等于 1 的时候，循环退出。这里要注意w -= 1，等同于w = w - 1。
下一个程序我们写入/home/shiyanlou/investment.py，来计算投资，使用 Vim 输入以下代码：

#!/usr/bin/env python3
amount = float(input("Enter amount: "))  # 输入数额
inrate = float(input("Enter Interest rate: "))  # 输入利率
period = int(input("Enter period: "))  # 输入期限
value = 0
year = 1
while year <= period:
    value = amount + (inrate * amount)
    print("Year {} Rs. {:.2f}".format(year, value))
    amount = value
    year = year + 1

运行程序：

$ cd /home/shiyanlou
$ chmod +x investment.py
$ ./investment.py
Enter amount: 10000
Enter Interest rate: 0.14
Enter period: 5
Year 1 Rs. 11400.00
Year 2 Rs. 12996.00
Year 3 Rs. 14815.44
Year 4 Rs. 16889.60
Year 5 Rs. 19254.15

while year <= period:的意思是，当year的值小于等于period的值时，下面的语句将会一直循环执行下去，直到year大于period时停止循环。
Year {} Rs. {:.2f}".format(year, value)称为字符串格式化，大括号和其中的字符会被替换成传入str.format()的参数，也即year和value。其中{:.2f}的意思是替换为 2 位精度的浮点数。

代码示例

一些关于变量和数据类型的代码实例。下面的例子程序请都写在/home/shiyanlou目录下。

本部分包括下面的几个实例：

1. 求 N 个数字的平均值
2. 华氏温度到摄氏温度转换程序

请按照指定目录完成每个程序，并理解每个程序中每行代码的含义。

求N个数字的平均值

下面的程序用来求 N 个数字的平均值。请将程序代码写入到文件/home/shiyanlou/averagen.py中，程序中将需要输入 10 个数字，最后计算 10 个 数字的平均值。

代码内容，请理解每一行代码含义：

#!/usr/bin/env python3
N = 10
sum = 0
count = 0
print("please input 10 numbers:")
while count < N:
    number = float(input())
    sum = sum + number
    count = count + 1
average = sum / N
print("N = {}, Sum = {}".format(N, sum))
print("Average = {:.2f}".format(average))

运行程序过程，需要输入 10 个数字：

$ cd /home/shiyanlou
$ chmod +x averagen.py
$ ./averagen.py
1.2
3.4
3.5
33.2
2
4
6
2.4
4
5.5
N = 10, Sum = 65.2
Average = 6.52

温度转换

在下面的程序里，我们使用公式 C = (F - 32) / 1.8 将华氏温度转为摄氏温度。

#!/usr/bin/env python3
fahrenheit = 0
print("Fahrenheit Celsius")
while fahrenheit <= 250:
    celsius = (fahrenheit - 32) / 1.8 # 转换为摄氏度
    print("{:5d} {:7.2f}".format(fahrenheit , celsius))
    fahrenheit = fahrenheit + 25

{:5d}的意思是替换为 5 个字符宽度的整数，宽度不足则使用空格填充。{:7.2f}的意思是替换为为7个字符宽度的保留两位的小数，小数点也算一个宽度，宽度不足则使用空格填充。其中7指宽度为7，.2f指保留两位小数。
运行程序：

$ cd /home/shiyanlou
$ chmod +x temperature.py
$ ./temperature.py
Fahrenheit Celsius
    0  -17.78
   25   -3.89
   50   10.00
   75   23.89
  100   37.78
  125   51.67
  150   65.56
  175   79.44
  200   93.33
  225  107.22
  250  121.11

单行定义多个变量或复制

你甚至可以在一行内将多个值赋值给多个变量。

在终端中输入：

$ python3

进入到 python3 交互式界面：

>>> a , b = 45, 54
>>> a
45
>>> b
54

这个技巧用来交换两个数的值非常方便。

>>> a, b = b , a
>>> a
54
>>> b
45

要明白这是怎么工作的，你需要学习元组（tuple）这个数据类型。我们是用逗号创建元组。在赋值语句的右边我们创建了一个元组，我们称这为元组封装（tuple packing），赋值语句的左边我们则做的是元组拆封 （tuple unpacking）。
下面是另一个元组拆封的例子：

>>> data = ("shiyanlou", "China", "Python")
>>> name, country, language = data
>>> name
'shiyanlou'
>>> country
'China'
>>> language
'Python'

总结

完成这个实验我们应该了解到以下的内容：

1. Python3 关键字有哪些（在这里不要求全部记住）
2. 变量如何赋值变量
3. Python3 怎样从键盘读取输入
4. Python3 字符串的格式化
5. 元组封装和拆封

在这里可以了解更多有关字符串格式化的信息：https://docs.python.org/3/library/string.html#formatstrings。

3.运算符和表达式

实验介绍

在 Python 中你会写大量的表达式。

表达式由运算符和操作数组成，像2+3就是一个表达式，其中 2 和 3 是操作数，加号是运算符。

本节实验中我们将学习运算符和表达式的基本用法。

知识点

• 关系/逻辑运算
• 表达式
• 类型转换

运算符

运算符是一些符号，它告诉 Python 解释器去做一些数学或逻辑操作。一些基本的数学操作符如下所示：

>>> 2 + 3
5
>>> 23.0 - 3
20.0
>>> 22 / 12
1.8333333333333333

只要有任意一个操作数是浮点数，结果就会是浮点数。
进行除法运算时若是除不尽，结果将会是小数，这很自然，如果要进行整除，使用//运算符，它将返回商的整数部分。

%是求余运算符：

>>> 14 % 3
2

整数运算示例

整数运算符比较容易理解，代码如下：

#!/usr/bin/env python3
days = int(input("Enter days: "))
months = days // 30
days = days % 30
print("Months = {} Days = {}".format(months, days))

在终端里使用Vim输入上述代码后，用chmod命令赋予可执行权限，最后运行程序：

在Enter days:后获得用户输入的天数，然后获得月份数和天数，最后把这些数打印出来。你可以使用更容易的办法：

#!/usr/bin/env python3
days = int(input("Enter days: "))
print("Months = {} Days = {}".format(*divmod(days, 30)))

divmod(num1, num2)返回一个元组，这个元组包含两个值，第一个是 num1 和 num2 相整除得到的值，第二个是 num1 和 num2 求余得到的值，然后我们用*运算符拆封这个元组，得到这两个值。

关系运算符

你可以使用下面的运算符实现关系运算。

关系运算符

在终端里输入python3进入交互页面,试一试以下一些例子：

>>> 1 < 2
True
>>> 3 > 34
False
>>> 23 == 45
False
>>> 34 != 323
True

逻辑运算符

对于逻辑 与，或，非，我们使用and，or，not这几个关键字。

逻辑运算符and和or也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果A和C为真而B为假，A and B and C不会解析C。作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数。

关系运算可以通过逻辑运算符and和or组合，比较的结果可以用not来取反意。逻辑运算符的优先级又低于关系运算符，在它们之中，not具有最高的优先级，or优先级最低，所以A and not B or C等于(A and (notB)) or C。当然，括号也可以用于比较表达式。

下面是一些例子：

>>> 5 and 4   # 首先判断5，肯定为true，那么最终的结果就取决于 and 后面那个的布尔值，4 的布尔值为 true，这样就可以确定整个表达式的值为 true 了，所以返回 4
4
>>> 0 and 4   # 首先判断0，因为 0 的布尔值为 false，那么不管 and 后面那个的布尔值是什么，整个表达式的布尔值都应该为 false 了，这个时候就不需要判断 4 了，直接返回最先确定结果的那个数也就是0
0
>>> False or 3 or 0
3
>>> 2 > 1 and not 3 > 5 or 4
True

简写运算符

x op= expression为简写运算的语法形式。其等价于x = x op expression，举例如下：

>>> a = 12
>>> a += 13
>>> a
25
>>> a /= 3
>>> a
8.333333333333334
>>> a += (26 * 32)
>>> a
840.3333333333334

/home/shiyanlou/shorthand.py示例，输入quit()退出python交互页面，用Vim写入以下代码：

#!/usr/bin/env python3
N = 100
a = 2
while a < N:
    print(str(a))
    a *= a

运行程序：

$ cd /home/shiyanlou
$ chmod +x shorthand.py
$ ./shorthand.py
2
4
16

表达式

通常我们书写表达式的时候，会在每一个运算符左右都放一个空格，这样使代码更可读，如：

a = 234 * (45 - 56 / 34)

一个用于展示表达式的例子，注意其中运算符的优先级。

#!/usr/bin/env python3
a = 9
b = 12
c = 3
x = a - b / 3 + c * 2 - 1
y = a - b / (3 + c) * (2 - 1)
z = a - (b / (3 + c) * 2) - 1
print("X = ", x)
print("Y = ", y)
print("Z = ", z)

运行程序：

$ cd /home/shiyanlou
$ chmod +x evaluationexp.py
$ ./evaluationexp.py
X = 10.0
Y = 7.0
Z = 4.0

第一个计算的是x，步骤如下：

9 - 12 / 3 + 3 * 2 -1
9 - 4 + 3 * 2 - 1
9 - 4 + 6 - 1
5 + 6 - 1
11 - 1
10

由于括号的存在，y和z的计算方式不同，你可以自己去验证它们。

类型转换

我们可以手动的执行类型转换。

>>> a = 8.126768
>>> str(a)
'8.126768'

可以分别尝试下前面的四个类型转换函数。

程序示例

2.7.1. evaluateequ.py

这个程序计算数列1/x+1/(x+1)+1/(x+2)+ … +1/n，我们设 x = 1，n = 10。

使用Vim写入以下代码：

#!/usr/bin/env python3
sum = 0
for i in range(1, 11):
    sum += 1.0 / i
    print("{:2d} {:6.4f}".format(i , sum))

运行程序：

2.7.2. quadraticequation.py

这个程序的名称为quadratic equation组合，是二次方程的英文词组。

这个程序用来求解二次方程式：

#!/usr/bin/env python3
import math
a = int(input("Enter value of a: "))
b = int(input("Enter value of b: "))
c = int(input("Enter value of c: "))
d = b * b - 4 * a * c
if d < 0:
    print("ROOTS are imaginary")
else:
    root1 = (-b + math.sqrt(d)) / (2 * a)
    root2 = (-b - math.sqrt(d)) / (2 * a)
    print("Root 1 = ", root1)
    print("Root 2 = ", root2)

运行程序：

2.7.3. salesmansalary.py

这个程序计算一位数码相机销售人员的工资。他的基本工资是 1500，每售出一台相机他可以得到 200 并且获得 2% 的抽成。程序要求输入相机数量及单价。

#!/usr/bin/env python3
basic_salary = 1500
bonus_rate = 200
commission_rate = 0.02
numberofcamera = int(input("Enter the number of inputs sold: "))
price = float(input("Enter the price of camera: "))
bonus = (bonus_rate * numberofcamera)
commission = (commission_rate * price * numberofcamera)
print("Bonus        = {:6.2f}".format(bonus))
print("Commission   = {:6.2f}".format(commission))
print("Gross salary = {:6.2f}".format(basic_salary + bonus + commission))

运行程序：

shiyanlou:~/ $ ./salesmansalary.py
Enter the number of inputs sold: 5
Enter the price of camera: 2000
Bonus        = 1000.00
Commission   = 200.00
Gross salary = 2700.00

总结

本节实验知识点回顾：

• 关系/逻辑运算
• 表达式
• 类型转换

除了数值运算，关系和逻辑运算也是程序的重要组成部分。另外 Python 是强类型语言，所以必要的时候需要手动进行类型转换。

程序挑战：圆的面积

挑战：圆的面积

介绍

我们通过实验已经学习了基本的 Python 3 语法。现在我们就来用一个挑战来巩固一下我们的实验效果。

本挑战中，我们将实现一个程序用来计算半径为 2 的圆的面积并打印输出。

目标

在/home/shiyanlou/Code创建一个 Python 脚本CircleArea.py：

$ cd /home/shiyanlou/Code
$ touch CircleArea.py

CircleArea.py 能够计算出一个半径为2的圆的面积，并且把面积打印出来，保留小数点后10位。
不要使用 input 等方法获得输入，程序不需要输入任何参数，程序执行如下，直接输出半径为 2 的圆的面积：

$ python3 /home/shiyanlou/Code/CircleArea.py

提示语

• import math
• 使用format可以控制输出的小数位数，可以使用'{:.10f}'.format()来进行格式化输出保留 10 位小数
• 注意代码文件的路径必须是/home/shiyanlou/Code/CircleArea.py
• 请不要使用 input 获取输入，程序执行不需要任何输入的参数

知识点

• 导入模块
• 打印输出
• 运算符和表达式

参考代码

注意：请务必先独立思考获得 PASS 之后再查看参考代码，直接拷贝代码收获不大

/home/shiyanlou/Code/CircleArea.py参考代码：

import math
# 计算圆的面积
area = 2 * 2 * math.pi
# 格式化输出圆的面积，保留10位小数
print("{:.10f}".format(area))

4.控制流if-else

实验介绍

我们处理现实生活中的问题时会做出决定，就像决定买哪种相机或者怎样更好的打篮球。

同样我们写计算机程序的时候也要做相同的事情。

我们通过if-else语句来做决定，我们使用它来改变程序运行的流程。

知识点

• if 语句
• else 语句
• 真值检测

if语句

语法如下：

if expression:
    do this

如果表达式expression的值为真（不为零的任何值都为真），程序将执行缩进后的内容。务必要使用正确的缩进，在表达式为真的情况将会执行缩进的所有行。
一个简单的例子，使用vim写入文件/home/shiyanlou/number100.py，程序接受用户输入的一个数并且检查这个数是否小于 100。

#!/usr/bin/env python3
number = int(input("Enter a number: "))
if number < 100:
    print("The number is less than 100")

然后我们运行它：

$ cd /home/shiyanlou
$ chmod +x number100.py
$ ./number100.py

操作截图：

else语句

在上面的例子中，我们想要这样做：如果输入数大于 100 则打印 “Greater than”。我们使用else语句来做到这一点，它将在if语句未满足的情况时工作。

#!/usr/bin/env python3
number = int(input("Enter a number: "))
if number < 100:
    print("The number is less than 100")
else:
    print("The number is greater than 100")

运行它：

另一个非常基础的例子：

>>> x = int(input("Please enter an integer: "))
>>> if x < 0:
...      x = 0
...      print('Negative changed to zero')
... elif x == 0:
...      print('Zero')
... elif x == 1:
...      print('Single')
... else:
...      print('More')

在上面的例子中，elif是else if的缩写。

真值检验

检测真值的优雅方式是这样的：

if x:
    pass

不要像下面这样做：

if x == True:
    pass

总结

这个实验非常简单，这里只是提一句，Python 中的很多值是具有布尔意义的，所以有时候我们可以写的更优雅一点。

同时也要注意下if``elif``else的基本语法结构。

5.循环

在以前的例子里，有些时候我们需要多次执行相同的任务，我们使用一个计数器来检查代码需要执行的次数。这个技术被称为循环。

实验知识点

• while 循环
• print() 函数的 end 参数

• 列表

  • 索引
  • 切片
• for 循环
• range() 函数
• continue 关键字
• for 循环中的 else 关键字

while循环

while语句的语法如下：

while condition:
    statement1
    statement2

想要多次执行的代码必须以正确的缩进放在while语句下面。在表达式condition为真的时候它们才会执行。同if-else一样，非零值为真。启动python3交互页面，让我们写一个简单的代码，它按顺序打印 0 到 10 的数字：

>>> n = 0
>>> while n < 11:
...     print(n)
...     n += 1
...
0
1
2
3
4
5
6
7
8
9
10

在第一行我们使n = 0，然后在while语句中把条件设置为n < 11，这意味着在while语句下面缩进的所有行将会被执行，直到n的值大于等于11。在循环里我们只是打印 n 的值然后令它增一。
想想如果没有循环语句，你想要打印 0 到 10 的所有数字，那你得手动打印 11 次！

斐波那契（Fibonacci）数列

让我们来试试打印斐波那契数列。这个数列前两项为 1，之后的每一个项都是前两项之和。所以这个数列看起来就像这样：1,1,2,3,5,8,13 ……

#!/usr/bin/env python3
a, b = 0, 1
while b < 100:
    print(b)
    a, b = b, a + b

运行程序：

第一行代码中我们初始化a和b。当b的值小于 100 的时候，循环执行代码。循环里我们首先打印b的值，然后在下一行将a + b的值赋值给b，b的值赋值给a。

学习其他语言的同学在这里可能有些困惑，你可以这样理解，Python 中赋值语句执行时会先对赋值运算符右边的表达式求值，然后将这个值赋值给左边的变量。

默认情况下，print()除了打印你提供的字符串之外，还会打印一个换行符，所以每调用一次print()就会换一次行，如同上面一样。

你可以通过print()的另一个参数end来替换这个换行符，就像下面这样，下面的程序写入/home/shiyanlou/fibonacci2.py：

#!/usr/bin/env python3
a, b = 0, 1
while b < 100:
    print(b, end=' ')
    a, b = b, a + b
print()

运行程序：

$ cd /home/shiyanlou
$ chmod +x fibonacci2.py
$ ./fibonacci2.py

幂级数

我们来写一个程序计算幂级数：e^x = 1 + x + x^2 / 2! + x^3 / 3! + … + x^n / n!（0 < x < 1）。

该程序写入代码文件/home/shiyanlou/powerseries.py

#!/usr/bin/env python3
x = float(input("Enter the value of x: "))
n = term = num = 1
result = 1.0
while n <= 100:
    term *= x / n
    result += term
    n += 1
    if term < 0.0001:
        break
print("No of Times= {} and Sum= {}".format(n, result))

运行程序：

在这个程序里我们介绍一个新的关键字break，它可以终止最里面的循环。这个例子里我们在if语句里使用break：

if term < 0.0001:
    break

这意味着如果term的值小于0.0001，那么终止循环。

乘法表

这个例子里我们打印 10 以内的乘法表。写入代码文件/home/shiyanlou/multiplication.py

#!/usr/bin/env python3
i = 1
print("-" * 50)
while i < 11:
    n = 1
    while n <= 10:
        print("{:5d}".format(i * n), end=' ')
        n += 1
    print()
    i += 1
print("-" * 50)

运行如下：

这里我们在while循环里使用了另一个while循环，这被称为嵌套循环。你应该已经看到一条有趣的语句：

print("-" * 50)

字符串若是乘上整数 n，将返回由 n 个此字符串拼接起来的新字符串。
下面是一些例子：

>>> 's' * 10
'ssssssssss'
>>> print("*" * 10)
**********
>>> print("#" * 20)
####################
>>> print("--" * 20)
----------------------------------------
>>> print("-" * 40)
----------------------------------------

一些打印星号的例子

这里是一些你可以在大学的实验报告里经常看到的例子。

2.4.1. 设计 1

#!/usr/bin/env python3
row = int(input("Enter the number of rows: "))
n = row
while n >= 0:
    x =  "*" * n
    print(x)
    n -= 1

运行这个程序：

2.4.2. 设计 2

#!/usr/bin/env python3
n = int(input("Enter the number of rows: "))
i = 1
while i <= n:
    print("*" * i)
    i += 1

运行这个程序：

2.4.3 设计 3

#!/usr/bin/env python3
row = int(input("Enter the number of rows: "))
n = row
while n >= 0:
    x = "*" * n
    y = " " * (row - n)
    print(y + x)
    n -= 1

运行这个程序：

列表

在继续学习循环之前，我们先学习一个叫做列表的数据结构。它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型：

>>> a = [ 1, 342, 223, 'India', 'Fedora']
>>> a
[1, 342, 223, 'India', 'Fedora']

你可以将上面的列表想象为一堆有序的盒子，盒子包含有上面提到的值，每个盒子都有自己的编号（红色的数字），编号从零开始，你可以通过编号访问每一个盒子里面的值。对于列表，这里的编号称为索引。

我们像下面这样通过索引来访问列表中的每一个值：

>>> a[0]
1
>>> a[4]
'Fedora'

如果我们使用负数的索引，那将会从列表的末尾开始计数，像下面这样：

>>> a[-1]
'Fedora'

你甚至可以把它切成不同的部分，这个操作称为切片，例子在下面给出：

>>> a[0:-1]
[1, 342, 223, 'India']
>>> a[2:-2]
[223]

切片并不会改变正在操作的列表，切片操作返回其子列表，这意味着下面的切片操作返回列表一个新的（栈）拷贝副本：

>>> a[:]
[1, 342, 223, 'India', 'Fedora']

切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小：

>>> a[:-2]
[1, 342, 223]
>>> a[-2:]
['India', 'Fedora']

有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个元素之间 。左边第一个元素的索引为 0，而长度为 n 的列表其最后一个元素的右界索引为 n。例如：

 +---+-----+-----+---------+----------+
 | 1 | 342 | 223 | 'India' | 'Fedora' |
 +---+-----+-----+---------+----------+
   0    1     2       3        4          5
  -5   -4    -3      -2       -1

上面的第一行数字给出列表中的索引点 0…5。第二行给出相应的负索引。切片是从 i 到 j 两个数值表示的边界之间的所有元素。
对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如a[2:4]是 2。

Python 中有关下标的集合都满足左闭右开原则，切片中也是如此，也就是说集合左边界值能取到，右边界值不能取到。

对上面的列表，a[0:5]用数学表达式可以写为[0,5)，其索引取值为0,1,2,3,4，所以能将a中所有值获取到。 你也可以用a[:5], 效果是一样的。

而a[-5:-1]，因为左闭右开原则，其取值为-5,-4,-3,-2是不包含-1的。

为了取到最后一个值，你可以使用a[-5:]，它代表了取该列表最后5个值。

试图使用太大的索引会导致错误：

>>> a[32]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> a[-10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Python 能够优雅地处理那些没有意义的切片索引：一个过大的索引值(即大于列表实际长度)将被列表实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空列表:

>>> a[2:32]
[223, 'India', 'Fedora']
>>> a[32:]
[]

切片操作还可以设置步长，就像下面这样：

>>> a[1::2]
[342, 'India']

它的意思是，从切片索引 1 到列表末尾，每隔两个元素取值。
列表也支持连接这样的操作，它返回一个新的列表：

>>> a + [36, 49, 64, 81, 100]
[1, 342, 223, 'India', 'Fedora', 36, 49, 64, 81, 100]

列表允许修改元素：

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes[3] = 64
>>> cubes
[1, 8, 27, 64, 125]

也可以对切片赋值，此操作可以改变列表的尺寸，或清空它：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # 替换某些值
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # 现在移除他们
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 通过替换所有元素为空列表来清空这个列表
>>> letters[:] = []
>>> letters
[]

细心的同学可能发问了，前面不是说过切片操作不改变列表么？严格来说，这里并不算真正的切片操作，只是上面代码中赋值运算符左边的这种操作与切片操作形式一样而已。
要检查某个值是否存在于列表中，你可以这样做：

>>> a = ['ShiYanLou', 'is', 'cool']
>>> 'cool' in a
True
>>> 'Linux' in a
False

这意味着我们可以将上面的语句使用在if子句中的表达式。通过内建函数len()我们可以获得列表的长度：

>>> len(a)
3

如果你想要检查列表是否为空，请这样做：

if list_name: # 列表不为空
    pass
else: # 列表为空
    pass

列表是允许嵌套的（创建一个包含其它列表的列表），例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

for循环

通过for语句我们可以使用 for 循环。Python 里的 for 循环与 C 语言中的不同。这里的 for 循环遍历任何序列（比如列表和字符串）中的每一个元素。下面给出示例：

>>> a = ['ShiYanLou', 'is', 'powerful']
>>> for x in a:
...     print(x)
...
ShiYanLou
is
powerful

我们也能这样做：

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> for x in a[::2]:
...     print(x)
1
3
5
7
9

range() 函数

如果你需要一个数值序列，内置函数range()会很方便，它生成一个等差数列（并不是列表）：

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>> range(1, 5)      
range(1, 5)
>>> list(range(1, 5))
[1, 2, 3, 4]
>>> list(range(1, 15, 3))
[1, 4, 7, 10, 13]
>>> list(range(4, 15, 2))
[4, 6, 8, 10, 12, 14]

comtinue语句

如同break，我们可以在循环中使用另一个语句continue。它会跳过其后的代码回到循环开始处执行。这意味着它可以帮助你跳过部分循环。在下面的例子中，我们要求用户输入一个整数，如果输入的是负数，那么我们会再次要求输入，如果输入的是整数，我们计算这个数的平方。用户输入 0 来跳出这个无限循环。

#!/usr/bin/env python3
while True:
    n = int(input("Please enter an Integer: "))
    if n < 0:
        continue # 这会返回到循环开始处执行
    elif n == 0:
        break
    print("Square is ", n ** 2)
print("Goodbye")

运行程序：

循环的else语句

我们可以在循环后面使用可选的else语句。它将会在循环完毕后执行，除非有break语句终止了循环。

>>> for i in range(0, 5):
...     print(i)
... else:
...     print("Bye bye")
...
0
1
2
3
4
Bye bye

在本课程的后续内容中，我们会看到更多有关break和continue的例子。

棍子游戏

这是一个非常简单的游戏。这里有 21 根棍子，首先用户选 1 到 4 根棍子，然后电脑选 1到 4 根棍子。谁选到最后一根棍子谁就输。判断一下用户有赢的机会吗？如果没有的话，如何修改游戏规则可以使用户有赢的机会呢？

特别说明：用户和电脑一次选的棍子总数只能是5。

#!/usr/bin/env python3
sticks = 21
print("There are 21 sticks, you can take 1-4 number of sticks at a time.")
print("Whoever will take the last stick will loose")
while True:
    print("Sticks left: " , sticks)
    if sticks == 1:
        print("You took the last stick, you loose")
        break
    sticks_taken = int(input("Take sticks(1-4):"))
    if sticks_taken >= 5 or sticks_taken <= 0:
        print("Wrong choice")
        continue
    print("Computer took: " , (5 - sticks_taken) , "\n")
    sticks -= 5

总结

这个实验中我们了解了两种循环：while和for循环，其中的for循环我们通常与range()函数配合使用，要特别注意的是，range()函数返回的并不是列表而是一种可迭代对象：

python 中for循环的else子句给我们提供了检测循环是否顺利执行完毕的一种优雅方法。

6.数据结构

实验介绍

Python 有许多内建的数据结构。如果你困惑于什么是数据结构，那么可以参考一下Wikipedia 。

简单的来说，数据结构（data structure）是计算机中存储、组织数据的方式。比如我们之前的课程中使用过的列表就是一种数据结构，在这里我们还会深入学习它。

知识点

• 列表的方法与列表元素的删除
• 将列表用作栈和队列
• 列表推导式
• 元组、集合、字典的创建与操作
• enumerate()和zip()函数

列表

>>> a = [23, 45, 1, -3434, 43624356, 234]
>>> a.append(45)
>>> a
[23, 45, 1, -3434, 43624356, 234, 45]

首先我们建立了一个列表a。然后调用列表的方法a.append(45)添加元素45到列表末尾。你可以看到元素 45 已经添加到列表的末端了。有些时候我们需要将数据插入到列表的任何位置，这时我们可以使用列表的insert()方法。

>>> a.insert(0, 1) # 在列表索引 0 位置添加元素 1
>>> a
[1, 23, 45, 1, -3434, 43624356, 234, 45]
>>> a.insert(0, 111) # 在列表索引 0 位置添加元素 111
>>> a
[111, 1, 23, 45, 1, -3434, 43624356, 234, 45]

列表方法count(s)会返回列表元素中s的数量。我们来检查一下45这个元素在列表中出现了多少次。

>>> a.count(45)
2

如果你想要在列表中移除任意指定值，你需要使用remove()方法。

>>> a.remove(234)
>>> a
[111, 1, 23, 45, 1, -3434, 43624356, 45]

现在我们反转整个列表。

>>> a.reverse()
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111]

怎样将一个列表的所有元素添加到另一个列表的末尾呢，可以使用列表的extend()方法。

>>> b = [45, 56, 90]
>>> a.extend(b) # 添加 b 的元素而不是 b 本身
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111, 45, 56, 90]

给列表排序，我们使用列表的sort()方法，排序的前提是列表的元素是可比较的。

>>> a.sort()
>>> a
[-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111, 43624356]

你也能使用del关键字删除指定位置的列表元素。

>>> del a[-1]
>>> a
[-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111]

将列表用作栈和队列

栈是我们通常所说的一种LIFO（Last In First Out 后进先出）数据结构。它的意思是最后进入的数据第一个出来。一个最简单的例子往一端封闭的管道放入一些弹珠然后取出来，如果你想把弹珠取出来，你必须从你最后放入弹珠的位置挨个拿出来。用代码实现此原理：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.pop()
6
>>> a.pop()
5
>>> a.pop()
4
>>> a.pop()
3
>>> a
[1, 2]
>>> a.append(34)
>>> a
[1, 2, 34]

上面的代码中我们使用了一个新方法pop()。传入一个参数 i 即pop(i)会将第 i 个元素弹出。
在我们的日常生活中会经常遇到队列，比如售票窗口、图书馆、超市的结账出口。队列是一种在末尾追加数据以及在开始弹出数据的数据结构。与栈不同，它是FIFO（First In First Out 先进先出）的数据结构。

>>> a = [1, 2, 3, 4, 5]
>>> a.append(1)
>>> a
[1, 2, 3, 4, 5, 1]
>>> a.pop(0)
1
>>> a.pop(0)
2
>>> a
[3, 4, 5, 1]

我们使用a.pop(0)弹出列表中第一个元素。

列表推导式

列表推导式为从序列中创建列表提供了一个简单的方法。如果没有列表推导式，一般都是这样创建列表的：通过将一些操作应用于序列的每个成员并通过返回的元素创建列表，或者通过满足特定条件的元素创建子序列。

假设我们创建一个 squares 列表，可以像下面这样创建。

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

注意这个 for 循环中的被创建（或被重写）的名为x的变量在循环完毕后依然存在。使用如下方法，我们可以计算 squares 的值而不会产生任何的副作用：。

squares = list(map(lambda x: x**2, range(10)))

等价于下面的列表推导式。

squares = [x**2 for x in range(10)]

上面这个方法更加简明且易读。
列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。

例如，如下的列表推导式结合两个列表的元素，如果元素之间不相等的话：

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等同于：

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

值得注意的是在上面两个方法中的 for 和 if 语句的顺序。
列表推导式也可以嵌套。

>>> a=[1,2,3]
>>> z = [x + 1 for x in [x ** 2 for x in a]]
>>> z
[2, 5, 10]

元组

元组是由数个逗号分割的值组成。

>>> a = 'Fedora', 'ShiYanLou', 'Kubuntu', 'Pardus'
>>> a
('Fedora', 'ShiYanLou', 'Kubuntu', 'Pardus')
>>> a[1]
'ShiYanLou'
>>> for x in a:
...     print(x, end=' ')
...
Fedora ShiYanLou Kubuntu Pardus

你可以对任何一个元组执行拆封操作并赋值给多个变量，就像下面这样：

>>> divmod(15,2)
(7, 1)
>>> x, y = divmod(15,2)
>>> x
7
>>> y
1

元组是不可变类型，这意味着你不能在元组内删除或添加或编辑任何值。如果你尝试这些操作，将会出错：

>>> a = (1, 2, 3, 4)
>>> del a[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

要创建只含有一个元素的元组，在值后面跟一个逗号。

>>> a = (123)
>>> a
123
>>> type(a)
<class 'int'>
>>> a = (123, )
>>> b = 321,
>>> a
(123,)
>>> b
(321,)
>>> type(a)
<class 'tuple'>
>>> type(b)
<class 'tuple'>

通过内建函数type()你可以知道任意变量的数据类型。还记得我们使用len()函数来查询任意序列类型数据的长度吗？

>>> type(len)
<class 'builtin_function_or_method'>

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合），intersection（交），difference（差）和 symmetric difference（对称差集）等数学运算。

大括号或 set() 函数可以用来创建集合。注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典，我们在下一节中介绍的一种数据结构。

下面是集合的常见操作：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 你可以看到重复的元素被去除
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
>>> # 演示对两个单词中的字母进行集合操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 去重后的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # a 有而 b 没有的字母
{'r', 'd', 'b'}
>>> a | b                              # 存在于 a 或 b 的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # a 和 b 都有的字母
{'a', 'c'}
>>> a ^ b                              # 存在于 a 或 b 但不同时存在的字母
{'r', 'd', 'b', 'm', 'z', 'l'}

从集合中添加或弹出元素：

>>> a = {'a','e','h','g'}
>>> a.pop()  # pop 方法随机删除一个元素并打印
'h'
>>> a.add('c')
>>> a
{'c', 'e', 'g', 'a'}

字典

字典是是无序的键值对（key:value）集合，同一个字典内的键必须是互不相同的。一对大括号{}创建一个空字典。初始化字典时，在大括号内放置一组逗号分隔的键：值对，这也是字典输出的方式。我们使用键来检索存储在字典中的数据。

>>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'}
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'}
>>> data['kart_']
'Debian'

创建新的键值对很简单：

>>> data['parthan'] = 'Ubuntu'
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}

使用del关键字删除任意指定的键值对：

>>> del data['kushal']
>>> data
{'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'

使用in关键字查询指定的键是否存在于字典中。

>>> 'ShiYanLou' in data
False

必须知道的是，字典中的键必须是不可变类型，比如你不能使用列表作为键。
dict()可以从包含键值对的元组中创建字典。

>>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
{'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}

如果你想要遍历一个字典，使用字典的items()方法。

>>> data
{'Kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
>>> for x, y in data.items():
...     print("{} uses {}".format(x, y))
...
Kushal uses Fedora
Jace uses Mac
kart_ uses Debian
parthan uses Ubuntu

许多时候我们需要往字典中的元素添加数据，我们首先要判断这个元素是否存在，不存在则创建一个默认值。如果在循环里执行这个操作，每次迭代都需要判断一次，降低程序性能。
我们可以使用dict.setdefault(key, default)更有效率的完成这个事情。

>>> data = {}
>>> data.setdefault('names', []).append('Ruby')
>>> data
{'names': ['Ruby']}
>>> data.setdefault('names', []).append('Python')
>>> data
{'names': ['Ruby', 'Python']}
>>> data.setdefault('names', []).append('C')
>>> data
{'names': ['Ruby', 'Python', 'C']}

试图索引一个不存在的键将会抛出一个keyError错误。我们可以使用dict.get(key, default)来索引键，如果键不存在，那么返回指定的 default 值。

>>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)
0

如果你想要在遍历列表（或任何序列类型）的同时获得元素索引值，你可以使用enumerate()。

>>> for i, j in enumerate(['a', 'b', 'c']):
...     print(i, j)
...
0 a
1 b
2 c

你也许需要同时遍历两个序列类型，你可以使用zip()函数。

>>> a = ['Pradeepto', 'Kushal']
>>> b = ['OpenSUSE', 'Fedora']
>>> for x, y in zip(a, b):
...     print("{} uses {}".format(x, y))
...
Pradeepto uses OpenSUSE
Kushal uses Fedora