Python 基础课程

1 环境搭建

1.1 安装

根据不同操作系统,采取不同安装程序安装,具体到官 网看指南和选择。

本地采用python3x,针对学习材料的python2x进行部分修改。

1.2 本地调试

使用终端操作,比如command line、PowerShell。

使用Sublime。安装和操作指南请看Sublime3搭建Python的IDE

需要为Sublime添加一个包SublimeREPL。

绑定快捷键F1(打开Python终端)和F2(直接编译结果),在Preferences -> Key Bindings-User下添加代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[
{
"keys":["f1"],
"caption": "SublimeREPL: Python",
"command": "run_existing_window_command",
"args": {
"id": "repl_python",
"file": "config/Python/Main.sublime-menu"
}
},
{
"keys":["f2"],
"caption": "SublimeREPL: Python - RUN current file",
"command": "run_existing_window_command",
"args": {
"id": "repl_python_run",
"file": "config/Python/Main.sublime-menu"
}
}
]

2 入门

2.1 基础材料

资 料
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
# python2 keyword
# python3 function
print ("Hello World!")
# 多行文本,首尾连续3个相同引号
long_string = '''Sing a song of sixpence, a pocket full of rye,
Four and twenty blackbirds baked in a pie.
When the pie was opened the birds began to sing.
Wasn't that a dainty dish to set before the king?'''
print (long_string)
# python2 int
# python3 float
print(3/2)
# python3 int
print(3//2)
# 平方
print(3**2)
# python2 raw_input()
# python3 input()
age = input("Input your age: ")
birth_year = 2014 - int(age)
print ("You are born in",birth_year)
from collections import Counter
a = [1,2,3,4,2,2,4,5,2,3,1]
# list中出现次数最多和第二多的
print(Counter(a).most_common(1))
print(Counter(a).most_common(2))
print(1 + 1 == 2 and 1 + 1 == 3)
print(1 + 1 == 2 or 1 + 1 == 3)
print(not 1 + 1 == 2)
print(4 not in [1, 2, 3])
light = "blue"
if light == "red":
print("Stop!")
elif light == "green":
print("Go!")
elif light == "yellow":
print("Slow down!")
else:
print("Nothing!")
your_num = input("请输入一个数: ")
your_num = int(your_num)
if your_num > 0:
print("It is positive")
elif your_num < 0:
print("It is negative")
else:
print("It is zero")
num = 1234
sum = 0
while num > 0:
sum = sum + num % 10
num = num // 10
print(sum)
# 从1加到100
num = 1
sum = 0
while num < 100:
sum = sum + num
num += 1
print(sum)
num = [1,2,3,-4,5]
for i in num:
if i < 0:
break
print(i)
for i in num:
if i < 0:
continue
print(i)
# 只打印偶数
num = [1, 3, 4, 5, 8, 7, 6, 2]
for i in num:
if i % 2 != 0:
continue
print(i)
contact = {"Lilei":"134521341","HanMeimei":"63436542"}
for i in contact:
print(i,":",contact[i])
note = {"Mom" : 14500, "Dad" : 24355, "Children" : 4560}
sum = 0
for i in note:
sum = sum + note[i]
print("一家子一共有多少钱:",sum)
# 计算奇数之和
num = [1, 3, 9, 23, 24, 45, 23, 43, 12, 88]
sum = 0
for i in num:
if i % 2 == 0:
continue
sum = sum + i
print("奇数之和为:",sum)
# 函数
def add_sum(num):
sum = 0
for i in num:
sum = sum + i
return sum
num = [1,2,3,5,2,1,3,9,3,4,5,6]
print(add_sum(num))
def calculate(note):
sum = 0
for i in note:
sum = sum + note[i]
return sum
print(calculate({"Mom" : 14500, "Dad" : 24355, "Children" : 4560}))
print(calculate({"Mom" : 13000, "Dad" : 20000, "Children" : 2800}))
# 作用域
x = 1
def changeX():
global x
x = 10
print("x in function is",x)
changeX()
print("x out of function is",x)
import math
print(math.pi)
print(math.sin(math.pi//2))
print(dir(math))
# 写一个函数接受一个int型参数,判断改参数是否为质数,返回布尔值。
# 写一个函数接受一个int型参数,返回该参数的所有因子,返回一个列表。
# 利用上面两个函数编写一个函数,接受一个int型参数,返回这个参数的最大质因子。
def is_prime(n):
if n % 2 == 0 and n > 2:
return False
for i in range(3, int(sqrt(n)) + 1):
if n % i == 0:
return False
return True
# 对象 指向相同内存空间
a = [1,2,3]
b = a
b[0] = 0
a[-1] = 4
print(b)
print(a)
a = [1,2]
b = [3,4]
a.append(b)
b.append(a)
print(a)
print(b)
# 类
class MyClass:
# 构造函数
def __init__(self):
self.name = "my class"
print("Initial the class,",self.name)
def set_name(self,name):
self.name = name
def out_put(self):
print(self.name)
# 实例化
cls = MyClass()
cls.out_put()
cls.set_name("David")
cls.out_put()
# 继承
class MyNewClass(MyClass):
def set_age(self,age):
self.age = age
def out_put_age(self):
print(self.age)
cls2 = MyNewClass()
cls2.out_put()
cls2.set_name("David")
cls2.out_put()
cls2.set_age(17)
cls2.out_put_age()
class Person:
def __init__(self):
self.name = "no name"
self.age = "no age"
self.gender = "no gender"
def input_message(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def output_message(self):
print("The name is:",self.name,"the age is:",self.age,"the gender is:",self.gender)
person = Person()
person.output_message()
new_name = input("Your name is: ")
new_age = input("Your age is: ")
new_gender = input("Your gender is: ")
person.input_message(new_name,new_age,new_gender)
person.output_message()
# 列表推导
nums = [1,2,3,4,5,6]
even = [i for i in nums if i % 2 == 0]
print(even)
odd = [i for i in nums if i % 2 != 0]
print(odd)
double_nums = [i*2 for i in nums]
print(double_nums)
# 链式比较
new_num = int(input("You press a number: "))
if 1 < new_num < 10:
print("The number is between 1 and 10")
# 交互变量 赋值特殊模式
str1 = "hello"
str2 = "world"
str1,str2 = str2,str1
x,y,z = 1,2,3
print(str1,str2)
print(x,y,z)
# for ... else ...
num = [1,2,3,5,6]
for i in num:
if i < 0:
break
print(i)
else:
print("all number are positive")
# 计数
from collections import Counter
c = Counter("Hello Lucy")
print(c)
print(c.most_common(2))
# 集合操作
A = {1,2,3,3}
B = {3,4,5,6,7}
print(A|B)
print(A&B)
print(A-B)
print(B-A)
print(A^B)
print((A-B)|(B-A))
print(B^A)
print((B-A)|(A-B))
# Python之禅
import this

3 学编程

Hello World!Computer Programming for Kids and Other Beginners

3.1 Unit One 出 发 吧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Number Guess
import random
secret = random.randint(1,99)
guess = 0
tries = 0
print ("AHOY! I'm the Dread Pirate Roberts, and I have a secret!")
print ("It is a number from 1 to 99. I'll give you 6 tries.")
while guess != secret and tries < 6:
guess = int(input("What's yer guess? "))
if guess < secret:
print ("Too low, ye scurvy dog!")
elif guess > secret:
print ("Too high, landlubber!")
tries = tries + 1
if guess == secret:
print ("Avast! Ye got it! Found my secret, ye did!")
else:
print ("No more guesses! Better luck next time, matey!")
print ("The secret number was", secret)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 出 发 吧
# 运行你的第二个 Python 程序: 猜数游戏。
# 1. 如何启动 IDLE ?
# 2. print 的作用是什么?
# 3. Python 中表示乘法的符号是什么?
# 4. 启动运行一个程序时 IDLE 会显示什么?
# 5. 运行程序又叫做什么?
# 1. 在交互模式中, 使用 Python 计算一周有多少分钟。
print ("计算一周有多少分钟")
week_days = int(input("一周有多少天? "))
day_hours = int(input("一天有多少小时? "))
hour_minutes = int(input("一小时有多少分钟? "))
week_minutes = week_days * day_hours * hour_minutes
print ("计算一周有",week_minutes,"分钟")
# 编写一个简短的小程序, 打印 3 行: 你的名字、 出生日期, 还有你最喜欢的颜色。
print ("个人信息")
name = input("What's your name? ")
birthday = input("What day is your birthday? ")
color = input("What's your favorite color? ")
print("My name is",name)
print("I was born",birthday)
print("My favorite color is",color)

3.2 Unit Two 记住内存和变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 记住内存和变量
# 1. 如何告诉 Python 变量是字符串(字符) 而不是数字?"1"
# 2. 一旦创建一个变量, 能不能改变赋给这个变量的值?yes
# 3. 变量名 TEACHER 与 TEACHEr 相同吗? no
# 4. 对 Python 来说, 'Blah' 与 "Blah" 一样吗? yes
# 5. 对 Python 来说, '4' 是不是等同于 4 ?no
# 6. 下面哪个变量名不正确? 为什么?
# (a) Teacher2
# (b) 2Teacher false
# (c) teacher_25
# (d) TeaCher
# 7. "10" 是数字还是字符串?string
# 1. 创建一个变量, 并给它赋一个数值(任何数值都行)。 然后使用 print 显示这个变量。
num = 5
print(num)
# 2. 改变这个变量, 可以用一个新值替换原来的值, 或者将原来的值增加某个量。使用 print 显示这个新值。
num = num + 1
print(num)
# 创建另一个变量, 并赋给它一个字符串(某个文本)。 然后使用 print 显示这个变量。
txt = 'hello'
print(txt)
# 计算一周有多少分钟。 不过, 这一次要使用变量。 以 DaysPerWeek(每周天数)、
# HoursPerDay(每天小时数) 和 MinutesPerHour(每小时分钟数) 为名分别创建变量
# (或者也可以用自己取的变量名), 然后将它们相乘。
print('计算一周有多少分钟')
DaysPerWeek = int(input("一周有多少天? "))
HoursPerDay = int(input("每天有多少小时? "))
MinutesPerHour = int(input("每小时有多少分钟? "))
MinutesPerWeek = DaysPerWeek * HoursPerDay * MinutesPerHour
print("一周有",MinutesPerWeek,"分钟")
# 如果一天有 26 个小时, 那么一周会有多少分钟呢?(提示: 改变 HoursPerDay 变量。)

3.3 Unit Three 基本数学运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 基本数学运算
# 1. Python 中乘法使用哪个符号? *
# 2. Python 计算 8 / 3 的答案是什么? 2(p2); 2.6666666666666665(p3)
# 3. 怎么得到 8 / 3 的余数? 8 % 3
# 4. 怎么得到 8 / 3 的小数结果?8.0 / 3; 8 / 3.0 (p2)
# 5. Python 中计算 6 * 6 * 6 * 6 的另一种做法是什么?6 ** 4
# 6. 采用 E 记法, 17 000 000 要写作什么? 1.7e7
# 7. 4.56e–5 如果按常规的写法是什么(不是 E 记法)?0.0000456
# 3 个人在餐厅吃饭, 想分摊饭费。 总共花费 35.27 美元, 他们还想留 15% 的小费。 每个人该怎么付钱?
people = int(input("How many people had the dinner? "))
total = float(input("How much is the dinner? "))
tip = 10 ** -2 * int(input("How much tip do you give? "))
pay = (total + total * tip) / people
print("Each one will pay:",pay)
# 计算一个 12.5m×16.7m 的矩形房间的面积和周长。
width = float(input("How is the width? "))
height = float(input("How is the height? "))
area = width * height
perimater = (width + height) * 2
print("The area is:",area)
print("The perimate:",perimater)
# 把温度从华氏度转换为摄氏度。 转换公式是 C = 5 / 9 * (F–32)。(提示: 当心整除问题!)
fahrenheit = float(input("How is the fahrenheit? "))
centigrade = 5 / 9 * (fahrenheit - 32)
print("The centigrade is:",centigrade)
# 相应的公式(用文字表述) 是“旅行时间等于距离除以速度”。
# 编写一个程序, 计算以 80 km/h 的速度行驶 200 km 需要花多长时间, 并显示答案。
speed = float(input("每小时的速度? "))
distence = float(input("距离? "))
time = distence / speed
print("旅行时间等于距离除以速度:",time)

3.4 Unit Four 数据的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# 数据的类型
# 你学到了什么
# 完成类型转换(或者更准确地说, 从某些类型创建另外一些类型): str()、int() 和 float()。
# 直接显示值, 而不使用 print。
# 使用 type() 查看变量的类型。
# 舍入误差及其出现的原因。
# 测试题
# 1. 使用 int() 将小数转换为整数, 结果是上取整还是下取整? 下取整
# 2. 在温度转换程序中, 可以这样做吗?
# cel = float(5 / 9 * (fahr – 32))
# 这样呢?
# cel = 5 / 9 * float(fahr – 32)
# 如果不行, 为什么?
fahr = 75
cel1 = float(5 / 9 * (fahr - 32))
print(cel1)
cel2 = 5 / 9 * float(fahr - 32)
print(cel2)
# Python 2 在进行除法运算时会默认向下取整,这里输出0。 Python 3 会默认进行浮点数除法这里输出23.88888888888889。
# 3.(挑战题) 除了 int() 不使用任何其他函数, 如何对一个数四舍五入而不是下
# 取整?(例如, 13.2 会下取整为 13, 但是 13.7 会上取整为 14。)
# 在区间0.1~0.4,增加0.5后,还在区间0.6~0.9,没有增一位,向下取整
num1 = float(input())
num2 = int(num1 + 0.5)
print(num2)
# 动手试一试
# 1. 使用 float() 从一个字符串(如 '12.34') 创建一个数。 要保证结果确实是
# 一个数!
# 2. 试着使用 int() 从一个小数(56.78) 创建一个整数。 答案是上取整还是下
# 取整?
# 3. 试着使用 int() 从一个字符串创建整数。 要保证结果确实是一个整数!
str1 = '12.34'
num3 = float(str1)
print(num3)
num4 = 56.78
num5 = int(num4)
print(num5)
str2 = '56.78'
num6 = int(float(str2))
print(num6)
print(type(num6))
# Python 2 <type 'int'>。 Python 3 <class 'int'>。

3.5 Unit Five 输  入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 输  入
# 在 Python 3 中, raw_input() 改名为 input() 了。 它与 Python 2中的 raw_input() 完全一样。
# Python 2 有 input() 的函数, 可以直接提供一个数; Python 3 移除该函数功能
print("Enter your name: ")
somebody = input()
print("Hi",somebody,"how are you today?")
# 在 Python 3 中使用 print() 时, 要打印的内容必须被包含在一对括号中。
print("My"),
print("name"),
print("is"),
print(somebody)
print("My",end=" ")
print("name",end=" ")
print("is",end=" ")
print(somebody)
print("This program converts Fahrenheit to Celsius")
print("Type in a temperature in Fahrenheit: ")
fahrenheit = float(input())
celsius = (fahrenheit - 32) * 5.0 / 9
print("That is",end=" ")
print(celsius,end=" ")
print("degrees Celsius")
# # 从互联网上的一个文件得到输入,使用命令行终端可以(不设置网络代理),sublime终端卡死
# from urllib import request
# file = request.urlopen('http://helloworldbook2.com/data/message.txt')
# message = file.read()
# # print(message)
# 在这一章, 你学到了以下内容。
# ˆˆ用 raw_input() 输入文本。
# ˆˆ向 raw_input() 增加一个提示消息。
# ˆˆ结合 int() 和 float() 使用 raw_input() 输入数字。
# ˆˆ使用逗号将多行打印到一行上。
# 测试题
# 1. 对于下面这行代码: answer = raw_input() 如果用户键入 12, answer 的数据类型是什么? 是字符串还是一个数? 字符串
print(type(input("输入12: ")))
# 2. 怎么让 raw_input() 打印一个提示消息? input("提示消息")
txt = input("提示消息: ")
print(txt)
# 3. 怎么使用 raw_input() 得到一个整数?
print(int(input("输入数字: ")))
# 4. 怎么使用 raw_input() 得到一个浮点数(小数)?
print(float(input("输入数字: ")))
# 动手试一试
# 1. 在交互模式中建立两个变量, 分别表示你的姓和名。 然后使用一条 print 语句, 把姓和名打印在一起。
# 2. 编写一个程序, 先问你的姓, 再问名, 然后打印一条消息, 在消息中包含你的姓和名。
yourFirstName = input("输入名: ")
yourLastName = input("输入姓:")
print("Hi",yourFirstName,yourLastName,"how are you today?")
# 3. 编写一个程序询问一间长方形房间的尺寸(单位是米), 然后计算覆盖整个房间总共需要多少地毯, 并显示出来。
# 4. 编写一个程序先完成第 3 题的要求, 不过还要询问每平方尺地毯的价格。 然后主程序显示下面 3 个内容:
# ˆˆ总共需要多少地毯, 单位是平方米。
# ˆˆ总共需要多少地毯, 单位是平方尺(1 平方米 = 9 平方尺)。
# ˆˆ地毯总价格。
length = float(input("length of the room in feet: "))
width = float(input("width of the room in feet: "))
cost_per_yard = float(input ('cost per square yard: '))
area_feet = length * width
area_yards = area_feet / 9
total_cost = area_yards * cost_per_yard
print("The room area is", area_feet, "square feet")
print("总共需要",area_feet,"平方米地毯")
print("总共需要",area_yards,"平方尺地毯")
print("地毯总价格:",total_cost)
# 5. 编写一个程序帮助用户统计她的零钱。 程序要问下面的问题。
# “有多少个五分币? ” “有多少个二分币? ” “有多少个一分币? ”
# 让程序给出这些零钱的总面值。
num1 = int(input("有多少个五分币? "))
num2 = int(input("有多少个二分币? "))
num3 = int(input("有多少个一分币? "))
total = num1 * 0.5 + num2 * 0.2 + num3 * 0.1
print("零钱的总面值:",total)
# 四分之一
quarters = int(input("How many quarters? "))
# 10分
dimes = int(input("How many dimes? "))
# 5分
nickels = int(input("How many nickels? "))
# 1分
pennies = int(input("How many pennies? "))
total = 0.25 * quarters + 0.10 * dimes + 0.05 * nickels + 0.01 * pennies
print("You nave a total of: ", total)

3.6 Unit Six GUI

EasyGui 是一个 Python 模块, 利用这个模块可以很容易地建立简单的 GUI。 可以从 Easygui官网下载。下载 easygui.py 或者一个包含 easygui.py 的 zip 文件。 要安装这个模块, 只需要把文件 easygui.py 放在 Python 能找到的位置。在你的硬盘上查找Python2安装的文件夹, 再把 easygui.py 放在这个文件夹里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import easygui
# 消息框
user_response = easygui.msgbox("Hello there!")
print(user_response)
# 按钮框
flavor = easygui.buttonbox("What is your favorite ice cream flavor?",choices = ['Vanilla', 'Chocolate', 'Strawberry'])
easygui.msgbox("You picked " + flavor)
# 选择框
flavor2 = easygui.choicebox("What is your favorite ice cream flavor?",choices = ['Vanilla', 'Chocolate', 'Strawberry'])
easygui.msgbox("You picked " + flavor2)
# 如果点击 Cancel, 程序会结束, 你还会看到一个错误。 这是因为程序的最后一行希望得到某个文本(如 Vanilla), 倘若你点击 Cancel, 它将得不到任何输入。
# 输入框
flavor3 = easygui.enterbox("What is your favorite ice cream flavor?")
easygui.msgbox("You entered " + flavor3)
# 默认值
flavor4 = easygui.enterbox("What is your favorite ice cream flavor?",default = 'Vanilla')
easygui.msgbox("You entered " + flavor4)
# 整数框
flavor5 = easygui.integerbox("Enter one integer.")
easygui.msgbox("You entered " + str(flavor5))
# 使用 EasyGui 的猜数游戏
import random
secret = random.randint(1,99)
guess = 0
tries = 0
easygui.msgbox("""AHOY! I'm the Dread Pirate Roberts, and I have a secret!
It is a number from 1 to 99.
I'll give you 6 tries.""")
while guess != secret and tries < 6:
guess = easygui.integerbox("What's yer guess, matey?")
if not guess: break
if guess < secret:
easygui.msgbox(str(guess) + " is too law, ye scurvy dog!")
elif guess > secret:
easygui.msgbox(str(guess) + " is too high, landlubber!")
tries = tries + 1
if guess == secret:
easygui.msgbox("Avast! Ye got it! Found my secret, ye did!")
else:
easygui.msgbox("No more guesses! The number was " + str(secret))
# 在这一章, 你学到了以下内容。
# 如何利用 EasyGui 建立简单的 GUI。
# 如何使用消息框 msgbox 显示消息。
# 如何使用按钮、 选择框和文本输入框(buttonbox、 choicebox、 enterbox、 integerbox) 得到输入。
# 如何为一个文本框设置默认输入。
# 如何使用 Python 的内置帮助系统。
# 测试题
# 1. 如何使用 EasyGui 生成消息框? easygui.msgbox()
# 2. 如何使用 EasyGui 得到字符串(一些文本) 输入? user_response = easygui.msgbox()
# 3. 如何使用 EasyGui 得到整数输入? easygui.integerbox()
# 4. 如何使用 EasyGui 得到浮点数(小数) 输入? float(easygui.enterbox())
# 5. 什么是默认值? 给出一个可能使用默认值的例子。 默认值就像“自动获得的答案” easygui.enterbox(default="默认值")
# 动手试一试
# 1. 试着修改第 5 章中的温度转换程序, 这一次要用 GUI 输入和输出而不是 raw_input() 和 print。
# easygui.msgbox("This program converts Fahrenheit to Celsius")
# fahrenheit = float(easygui.enterbox("Type in a temperature in Fahrenheit: "))
# celsius = (fahrenheit - 32) * 5.0 / 9
# print("That is",end=" ")
# print(celsius,end=" ")
# print("degrees Celsius")
# 2. 编写一个程序, 询问你的姓名, 然后是房间号、 街道和城市, 接下来是省 / 地区 / 州,
# 最后是邮政编码(所有这些都放在 EasyGui 对话框中)。 然后这个程序要显示一个寄信格式的完整地址, 类似于
# John Snead
# 28 Main Street
# Akron, Ohio
# 12345
user_name = easygui.enterbox("What is your name?")
user_address = easygui.enterbox("What is your street address?")
user_city = easygui.enterbox("What is your city?")
user_state = easygui.enterbox("What is your state or province?")
whole_addr = user_name + "\n" + user_address + "\n" + user_city + "\n" + user_state
easygui.msgbox("Here is your address:" + "\n" + whole_addr)

3.7 Unit Seven 判断再判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
# 判断再判断
# 把两个大于和小于操作符“串”在一起完成一个范围测试
num = int(float(input("Enter a number: ")))
if 1 <= num <= 100:
print(num,"is between 1 and 100")
else:
print(num,"is beyond the pale")
# 使用比较操作符
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
if num1 < num2:
print(num1,"is less than",num2)
if num1 > num2:
print(num1,"is greater than",num2)
if num1 == num2:
print(num1,"is equal to",num2)
if num1 != num2:
print(num1,"is not equal to",num2)
# 测试为假
answer = float(input("Enter a number from 1 to 15: "))
if answer >= 10:
print("You got at least 10!")
elif answer >= 5:
print("You got at least 5!")
elif answer >= 3:
print("You got at least 3!")
else:
print("You got less than 3!")
# 测试多个条件
# 使用 and
# 如果有两个以上的条件,所有条件都必须为真,就会执行代码块
age = float(input("Enter your age: "))
grade = int(input("Enter your grade: "))
if age >= 8 and grade >= 3:
print("You can play this game.")
else:
print("Sorry, you can’t play the game.")
# 使用 or
# 只要任意一个条件为真,就会执行代码块
age = float(input("Enter your age: "))
grade = int(input("Enter your grade: "))
if age >= 8 or grade >= 3:
print("You can play this game.")
else:
print("Sorry, you can’t play the game.")
# 使用 not
# 把比较倒过来, 表示相反的逻辑
age = float(input("Enter your age: "))
grade = int(input("Enter your grade: "))
if not age < 8 or grade >= 3:
print("You can play this game.")
else:
print("Sorry, you can’t play the game.")
# 在这一章, 你学到了以下内容
# 比较测试和关系操作符
# 缩进和代码块
# 使用 and 和 or 结合测试
# 使用 not 来进行反向测试
# 测试题
# 1. 运行这个程序会得到什么输出:
my_number_1 = 7
if my_number_1 < 20:
print('Under 20')
else:
print('20 or over')
# 2. 基于第一个问题中的程序, 如果把 my_number 改为 25, 输出会是什么?
# 3. 要检查一个数是否大于 30 但小于或等于 40, 要用哪种 if 语句?
my_number_2 = int(float(input("Enter a number: ")))
if 30 < my_number_2 <= 40:
print(my_number_2,"大于 30 但小于或等于 40")
# 4. 要检查用户输入的字母“Q”是大写还是小写, 要使用哪种 if 语句?
my_str = input("Enter letter 'Q' or 'q': ")
if my_str == 'Q' or my_str == 'q':
if my_str == 'Q':
print(my_str,"is upper case")
else:
print(my_str,"is lower case")
# 动手试一试
# 1. 一家商场在降价促销。 如果购买金额低于或等于 10 元, 会给 10% 的折扣,
# 如果购买金额大于 10 元, 会给 20% 的折扣。 编写一个程序, 询问购买价格,
# 再显示折扣(10% 或 20%) 和最终价格。
my_price = float(input("Enter commodity price: "))
if my_price <= 10:
total = my_price * 0.9
elif my_price > 10:
total = my_price * 0.8
print("The commodity price is",total)
# 2. 一个足球队在寻找年龄在 10 到 12 岁之间的小女孩加入。 编写一个程序, 询问
# 用户的年龄和性别(m 表示男性, f 表示女性)。 显示一条消息指出这个人是否
# 可以加入球队。如果用户不是女孩就不必询问年龄
user_gender = input("Enter your gender, m is male, f is female: ")
if user_gender == 'f':
user_age = int(input("Enter your age: "))
if 10 <= user_age <= 12:
print("You can join in football team!")
print("You not the right age.")
else:
print("Only girl are allowed on the team.")
# 3. 你在长途旅行, 刚到一个加油站, 距下一个加油站还有 200 km。 编写一个程
# 序确定是不是需要在这里加油, 还是可以等到下一个加油站再加油。这个程序应当问下面几个问题:
# 你的油箱有多大(单位是升)?
# 油箱有多满(按百分比, 例如, 半满就是 50%)?
# 你的汽车每升油可以走多远(km)?
# 输出应该像这样:
# Size of tank: 60
# percent full: 40
# km per liter: 10
# You can go another 240 km
# The next gas station is 200 km away
# You can wait for the next station.
# 或者
# Get gas now!
# 程序中包含一个 5 升的缓冲区, 以防油表不准
capacity = int(input("Size of tank: "))
degree = int(input("percent full: "))
consumpsion = int(float(input("km per liter: ")))
buffer = 5
distance = (capacity - buffer) * (degree / 100.0) * consumpsion
target = 200
print("You can go another",distance,"km")
print("The next gas station is",target,"km away")
if distance >= target:
print("You can wait for the next station.")
else:
print("Get gas now!")
# 4. 建立一个程序, 用户必须输入密码才能使用这个程序。 你当然知道密码(因
# 为它会写在你的代码中)。 不过, 你的朋友要得到这个密码就必须问你或者直
# 接猜, 也可以学习足够的 Python 知识查看代码来找出密码!
# 对程序没什么要求, 可以是你已经编写的程序, 也可以是一个非常简单的程
# 序, 只在用户输入正确的口令时显示一条“You’re in!”之类的消息。
guess = input("You can enter your guess password: ")
pwd = "24jlj"
if guess == pwd:
print("Password corect. Welcome!")
# put the rest of the code for your program here
else:
print("Password incorrect. Goodbye!")

Unit Eight 转 圈 圈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# 转 圈 圈
# 重复一定次数的循环, 称为计数循环(counting loop)
for looper in [1,2,3,4,5]:
print("Hello")
for looper in [1,2,3,4,5]:
print(looper)
# 任何时刻(甚至在失控循环中) 要停止 一 个 Python 程 序
# 只 需 要 按 下 CTRL + C
for looper in [1,2,3,4,5]:
print(looper,"times 8 =",looper*8)
# 利用 range() 函数, 你可以只输入起始值和结束值,
# Python2
# range() 会创建一个列表, 从给定的第一个数开始, 在给定的最后一个数之前结束
# Python3
# range() 会提供一个“可迭代”(每次循环称为一次迭代)的东西
print(range(1,5))
# Python2 [1,2,3,4]
# Python3 range(1,5)
# for 循环中使用 range(), 则其工作方式是完全一样的,内部机制略有不同而已
for looper in range(1,5):
print(looper)
# 惯例通常使用字母 i、 j、 k 等作为循环变量
# 除了作为循环变量, i、 j、 k 不应当有其他用途
for i in range(1,5):
print(i,"times 8 =",i*8)
# range()简写
# 从 0 开始循环而不是从 1 开始
for i in range(5):
print(i)
for i in range(0,5):
print(i)
# 可以利用一个字符串来循环。 字符串中的每个字符对应循环中的一次迭代
for i in "Hello Python":
print(i)
# 按步长计数
# range() 函数可以有一个额外的参数, 利用这个参数可以把步长从默认的 1 改为不同的值
# 第 3 个参数是负数时, 循环会向下计数, 而不是向上计数
for i in range(1,5,2):
print(i)
for i in range(5,1,-1):
print(i)
import time
for i in range(10,0,-1):
print(i)
time.sleep(0.25)
print("BLAST OFF")
# 没有数字的计数
for cool_guy in ["Spongebob","Spiderman","Justin Timberlake","My Dad"]:
print(cool_guy,"is the coolest guy ever!")
# 重复直至发生某种情况时结束的循环, 称为条件循环(conditional loop)
print("Type 3 to continue, anything else to quit.")
someInput = input()
while someInput == '3':
print("Thank you for the 3. Very kind of you.")
print("Type 3 to continue, anything else to quit.")
someInput = input()
print("That's not 3, so I'm quitting now.")
# 跳出循环
# break 完全中止循环
# continue 直接跳到循环的下一次迭代
for i in range(1,6):
print("i =",i)
print("Hello how")
if i == 3:
break
print("are you today?")
for i in range(1,6):
print("i =",i)
print("Hello how")
if i == 3:
continue
print("are you today?")
# 在这一章, 你学到了以下内容
# for 循环(也称为计数循环)
# range() 函数—计数循环的一个捷径
# range() 的不同步长大小
# while 循环(也称为条件循环)
# 用 break 跳出循环
# 用 continue 跳到下一次迭代
# 测试题
# 1. 下面的循环会运行多少次?
for i in range(1,6):
print("Hi, Warren")
# 5次
# 2. 下面的循环会运行多少次? 每次循环时 i 的值是什么?
for i in range(1,6,2):
print("Hi, Warren")
# 3次
# 1
# 3
# 5
# 3. range(1,8)会给出一个怎样的数字列表?
# Python2 [1,2,3,4,5,6,7]
# 4. range(8)呢?
# Python2 [0,1,2,3,4,5,6,7]
# 5. range(2,9,2)呢?
# Python2 [2,4,6,8]
# 6. range(10,0,-2)呢?
# Python2 [10,8,6,4,2]
# 7. 使用continue关键字停止循环的当前迭代,提前跳到下一次迭代
# 8. while循环在满足条件时候结束
# 动手试一试
# 1. 编写一个程序, 显示一个乘法表。 开始时要询问用户显示哪个数的乘法表,使用了 for 循环
user_input = int(input("Which multiplication table would you like? "))
print("Here's your table:")
for i in range(1,11):
print(user_input,"X",i,"=",user_input*i)
# 2. 用 while 循环完成同样的工作完成第 1 题的程序
user_input = int(input("Which multiplication table would you like? "))
print("Here's your table")
i = 1
while i <= 10:
print(user_input,"X",i,"=",user_input*i)
i += 1
# 3. 向乘法表程序中再加点东西。 询问用户想要的乘法表之后, 再问问用户希望最大乘到几。
user_input = int(input("Which multiplication table would you like? "))
termination = int(input("How high do you want to go? ")) + 1
print("Here's your table:")
for i in range(1,termination):
print(user_input,"X",i,"=",user_input*i)

Unit Nine 全都为了你—注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 全都为了你—注释
# 注释是给你看的, 而不是让计算机执行的。
# 注释是程序文档的一部分, 计算机运行程序时会忽略这些注释。
# 在任何代码行前面加上“#”符号就可以把它变成一个注释。(这个符号叫做数字符号, 有时也叫做镑符号。)
# 这是Python程序中的一个注释
print("This is not a comment") # 这是计算机执行代码
# 有时你可能想使用多行注释。 可以使用多行, 每行前面都有一个 # 字符
# ***************
# 这个程序用来说明 Python 中如何使用注释
# 星号所在的行只为将注释
# 与其余代码清楚地区分开
# ***************
"""
只需建立一个没有名字的三重引号字符串
三重引号字符串是一个可以跨多行的字符串
从严格的 Python 术语来讲这并不是一个真正的注释
不过也可以相当于注释
"""
"""
建议你尽可能增加注释
注释越多越好。宁可过于谨慎注释过多, 也比注释过少要好。
积累更多的编程经验后,你就会慢慢了解加多
少注释以及加哪种注释最适合了。
"""
"""
大多数代码编辑器(包括 IDLE) 都有一个特性,
允许你很快地注释整个代码块(也能很快地取消注释)。
sublime 注释快捷键 ctrl + /
"""
"""
你学到了什么
注释只是为了方便你(和其他人), 而不是用来帮助计算机。
注释还可以用来隔离部分代码, 不让它们运行。
可以使用三重引号字符串作为一种跨多行的注释。
"""

Unit Ten 游戏时间到了

Skier(滑 雪 的 人 ) 是 一个非常简单的滑雪游戏, 灵感来自一个名叫 SkiFree的游戏。

在这个游戏中, 你要滑下小山, 努力避开树而且要尽量捡起小旗。 捡起一个小旗得 10 分;碰到树则会丢掉 100 分。

Skier 使用一个名叫 Pygame 的模块来帮助实现图形。 Pygame 是一个 Python 模块(module) 。

安装pip

pip 是一个Python包管理工具,主要是用于安装 PyPI 上的软件包,可以替代 easy_install 工具

下载页面下载压缩文件pip-x.x.x.tar.gz,下载完成之后,解压到一个文件夹,用CMD控制台进入解压目录,终端输入:

1
python setup.py install

安装好之后,我们直接在命令行输入pip,同样会显示‘pip’不是内部命令,也不是可运行的程序。因为还没有添加环境变量,如果在PATH最后添加:C:\Python34\Scripts;(默认Python安装位置)

安装Pygame

下载页面下载相应安装程序。如果python3x,到此处选择,这里wheel是一种便于python安装的压缩格式,注意区分32位与64位。

把你自己下载的pygame-1.9.3-cp34-cp34m-win_amd64.whl文件放在一个全英文的盘符中,在dos命令窗口中,把对应的路径切换到该文件的路径,然后执行:

1
pip install pygame-1.9.3-cp34-cp34m-win_amd64.whl

学习资源

用到的示例代码、图片等资源到资源下。把使用到的Skier图片文件放在保存程序的同一个文件夹或目录中。 如果它们与程序不在同一个目录下,Python 就无法找到这些文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import pygame, sys, random
skier_images = ["skier_down.png","skier_right1.png",
"skier_right2.png","skier_left2.png",
"skier_left1.png"]
class SkierClass(pygame.sprite.Sprite):
"""docstring for SkierClass"""
# 创建滑雪者
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("skier_down.png")
self.rect = self.image.get_rect()
self.rect.center = [320,100]
self.angle = 0
# 滑雪者转向
def turn(self,dirction):
self.angle = self.angle + direction
if self.angle < -2:
self.angle = -2
if self.angle > 2:
self.angle = 2
center = self.rect.center
self.image = pygame.image.load(skier_images[self.angle])
self.rect = self.image.get_rect()
self.rect.center = center
speed = [self.angle,6-abs(self.angle)*2]
return speed
# 滑雪者移动
def move(self,speed):
self.rect.centerx = self.rect.centerx + speed[0]
if self.rect.centerx < 20:
self.rect.centerx = 20
if self.rect.centerx > 620:
self.rect.centerx = 620
class ObstacleClass(pygame.sprite.Sprite):
"""docstring for ObstacleClass"""
# 创建树和小旗
def __init__(self,image_file,location,type):
pygame.sprite.Sprite.__init__(self)
self.image_file = image_file
self.image = pygame.image.load(image_file)
self.rect = self.image.get_rect()
self.rect.center = location
self.type = type
self.passed = False
# 让场景向上退
def update(self):
global speed
self.rect.centery -= speed[1]
if self.rect.centery < -32:
self.kill() # 删除从屏幕上方退下的障碍物
# 创建一个窗口,包含随机的树和小旗
def create_map():
global obstacles
locations = []
for i in range(10):
row = random.randint(0,9)
col = random.randint(0,9)
location = [col*64+20,row*64+20+640]
if not (location in locations):
locations.append(location)
type = random.choice(["tree","flag"])
if type == "tree":
img = "skier_tree.png"
elif type == "flag":
img = "skier_flag.png"
obstacle = ObstacleClass(img,location,type)
obstacles.add(obstacle)
# 重绘屏幕
def animate():
screen.fill([255,255,255])
obstacles.draw(screen)
screen.blit(skier.image,skier.rect)
screen.blit(score_text,[10,10])
pygame.display.flip()
# 做好准备
pygame.init()
screen = pygame.display.set_mode([640,640])
clock = pygame.time.Clock()
skier = SkierClass()
speed = [0,6]
obstacles = pygame.sprite.Group()
map_position = 0
points = 0
create_map()
font = pygame.font.Font(None,50)
# 开始主循环
running = True
while running:
clock.tick(30) # 每秒更新30次图形
for event in pygame.event.get():
# 检查按键或者窗口是否关闭
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
speed = skier.turn(-1)
elif event.key == pygame.K_RIGHT:
speed = skier.turn(1)
skier.move(speed) # 移动滑雪者
map_position += speed[1] # 滚动场景
# 创建一个新窗口,包含场景
if map_position >= 640:
create_map()
map_position = 0
# 检查是否碰到树或者小旗
hit = pygame.sprite.spritecollide(skier,obstacles,False)
if hit:
if hit[0].type == "tree" and not hit[0].passed:
points = points - 100
skier.image = pygame.image.load("skier_crash.png")
animate()
pygame.time.delay(1000)
skier.image = pygame.image.load("skier_down.png")
skier.angle = 0
speed = [0,6]
hit[0].passed = True
elif hit[0].type == "flag" and not hit[0].passed:
points += 10
hit[0].kill()
obstacles.update()
# 显示得分
score_text = font.render("Score: " + str(points), 1, (0,0,0))
animate()
pygame.quit()

3.11 Unit Eleven 嵌套和可变循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
# 嵌套与可变循环
for multiplier in range(5,8):
for i in range(1,11):
print(i,"x",multiplier,"=",i*multiplier)
print()
numStars = int(input("How many stars do you want? "))
for i in range(numStars):
print('*',end=" ")
print()
# 内循环(for star in range (0, numStars):) 打印每个星号,
# 对每一行的每个星号分别运行一次
# 外循环(for line in range (0, numLines):) 对每行星号分别运行一次
numLines = int(input("How many lines of stars do you want? "))
numStars = int(input("How many stars do you want? "))
for line in range(numLines):
for stars in range(numStars):
print("*",end=" ")
print()
# “嵌套嵌套循环”(或双重嵌套循环)
numBlocks = int(input("How many blocks of stars do you want? "))
numLines = int(input("How many lines in each block? "))
numStars = int(input("How many stars per line? "))
for block in range(numBlocks):
for line in range(numLines):
for star in range(numStars):
print("*",end=" ")
print()
print()
numBlocks = int(input("How many blocks of stars do you want? "))
for block in range(1,numBlocks+1):
print("block =",block)
for line in range(1,block*2):
for star in range(1,(block+line)*2):
print("*",end=" ")
print("line =",line,"star =",star)
print()
"""
排 列(permutation) 是 一 个 数 学 概 念, 表 示 结 合 一 组 事 物 的 唯 一 方 式。
组 合combination)与它很类似。它们的区别在于,对于组合,顺序并不重要,
而排列中顺序会有影响
建立一个列表,列出从 1 到 20 选择 3 个数
不同排列
5、8、14
8、5、14
相同组合
5、8、14
8、5、14
8、14、5
"""
"""
用数字显示如何订购热狗、 小面包、 番茄酱、 芥末酱和洋葱的所有可能的组合。
每个决策点都有两种选择, 是(Y) 或者否(N)。
这里有 5 个决策点, 所以在我们的决策树中有 5 层
使用制表符实现对齐,"\t"
计算卡路里
反斜线-行联接符
"""
print("\tHot Dog\tBun\tKetchup\tMustard\tOnions\tCalories")
count = 1
hotDog_cal = 140
bun_cal = 120
mus_cal = 20
ket_cal = 80
onion_cal = 40
for hotDog in range(2):
for bun in range(2):
for ketchup in range(2):
for mustard in range(2):
for onion in range(2):
total_cal = hotDog*hotDog_cal + bun*bun_cal +\
ketchup*ket_cal + mustard*mus_cal +\
onion*onion_cal
print("#",count,"\t",end=" ")
print(hotDog,"\t",bun,"\t",ketchup,"\t",end=" ")
print(mustard,"\t",onion,"\t",total_cal)
count += 1
# 你学到了什么
# 嵌套循环
# 可变循环
# 排列和组合
# 决策树
# 测试题
# Python中可以在range()函数中放一个变量来建立可变循环
# 要建立嵌套循环,需要把一个循环放在另一个循环的循环体中
# for i in range(5):
# for j in range(3):
# print("*")
# print()
# 打印15个星号
# 对于4层决策树,每层决策有两个选择,总共会有2的4次幂(16)种选择路径
# 动手试一试
# 1. 倒计时定时器,变为可变循环,询问用户向下计数从哪里开始
# import time
# for i in range(10,0,-1):
# print i
# time.sleep(0.25)
# print "BLAST OFF"
# Countdown timer asks the user where to start
countDown = int(input("How many seconds? "))
import time
for i in range(countDown,0,-1):
print(i)
time.sleep(0.25)
print("BLAST OFF")
# 2. 上一题程序改进,除了打印各个数之外,还要打印一行星号
# And prints stars beside each number
countDown = int(input("How many seconds? "))
for i in range(countDown,0,-1):
print(i,end=" ")
for j in range(i):
print("*",end=" ")
print()
time.sleep(0.25)
print("BLAST OFF")

Unit Twelve 收集起来-列表与字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
# 收集起来—列表与字典
# 向列表增加元素
friends = []
friends.append('David')
print(friends)
friends.append('Mary')
print(friends)
# 索引
myTeacher = ['Lucy']
another_list = [1,2,3]
my_list = [5,10,23.76,'Hello',myTeacher,7,another_list]
print(my_list[0])
# 列表分片(slicing)
letters = ['a','b','c','d']
print(letters[1:4])
# 分片(slice)另一个列表,原列表的部分副本(copy)
print(letters[1])
print(type(letters[1]))
print(letters[1:2])
print(type(letters[1:2]))
# 分片简写
# 起始位置到指定索引之间
print(letters[:2])
# 指定索引到结束位置之间
print(letters[2:])
# 整个列表
print(letters[:])
# 修改元素
letters[2] = 'z'
print(letters)
# letters[5] = 'e'
# IndexError: list assignment index out of range
letters[2] = 'c'
print(letters)
# 尾部增加一个元素
letters.append('e')
print(letters)
# 尾部增加多个元素
letters.extend(['f','g','h'])
print(letters)
# 插入一个元素
letters.insert(2,'z')
print(letters)
# 删除元素
letters.remove('z')
print(letters)
del letters[3]
print(letters)
letters.insert(3,'d')
# pop() 在列表删除和取出指定位置元素
# 无索引,最后一个
lastLetter = letters.pop()
print(lastLetter)
print(letters)
letters.append(lastLetter)
# 有索引,指定位置
second = letters.pop(1)
print(second)
print(letters)
letters.insert(1,second)
print(letters)
# 搜索列表
# in 关键字
# index()
if 'a' in letters:
print("found 'a' in letters")
findIndex = letters.index('a')
letters.remove('a')
else:
print("didn't find 'a' in letters")
letters.insert(findIndex,'a')
print(letters)
# 循环列表
for letter in letters:
print(letter)
# 列表排序
letters = ['d','a','e','c','b']
# 字母升序排序,修改原来列表
letters.sort()
print(letters)
# 字母降序排序,方法一
letters.reverse()
print(letters)
# 方法二
letters = ['d','a','e','c','b']
letters.sort(reverse=True)
print(letters)
# 建立列表副本
# 方法一,origin和new指向不同的列表
origin = [5,2,3,1,4]
new = origin[:]
# 方法二,sorted(),进行字母升序排序
newer = sorted(origin)
print(newer)
# 元组-不可改变的列表
my_tuple = ("red","green","blue")
# my_tuple.append("yellow")
# AttributeError: 'tuple' object has no attribute 'append'
# 双重列表-数据表
joeMarks = [55,63,77,81]
tomMarks = [65,61,67,72]
bethMarks = [97,95,92,88]
classMarks = [joeMarks,tomMarks,bethMarks]
for studentMarks in classMarks:
print(studentMarks)
print(classMarks[0][0])
"""
字典 dict
Python 字典(dictionary) 是一种将两个东西关联在一起的方式。
被关联在一起的两个东西分别称为键(key) 和值(value)。
字典无序
使用键来访问
键只可使用不可变类型
"""
phoneNumbers = {}
phoneNumbers["John"] = "555-1234"
phoneNumbers["Bob"] = "444-4321"
phoneNumbers["Jenny"] = "867-5309"
phoneNumbers["Mary"] = "555-6789"
print(phoneNumbers)
# 列出字典中所有的键
print(phoneNumbers.keys())
# 列出字典中所有的值
print(phoneNumbers.values())
# 对键排序,按键的排序显示字典
for key in sorted(phoneNumbers.keys()):
print(key,phoneNumbers[key])
# 对值排序
for value in sorted(phoneNumbers.values()):
for key in phoneNumbers.keys():
if phoneNumbers[key] == value:
print(key,phoneNumbers[key])
# 字典操作
# 删除一个条目
del phoneNumbers["Bob"]
print(phoneNumbers)
# 清空条目
phoneNumbers.clear()
print(phoneNumbers)
# in 关键字检查
phoneNumbers = {"Bob":"444-4321","Mary":"555-6789","Jenny":"867-5309"}
print("Bob" in phoneNumbers)
print("Barb" in phoneNumbers)
"""
你学到什么
列表是什么
如何向列表中增加元素
如何从列表删除元素
如何确定列表是否包含某个值
如何对列表排序
如何建立列表的副本
元组
双重列表
Python 字典
"""
"""
测试题
可以使用append(),insert(),extend向列表增加元素
可以使用remove(),pop(),del从列表删除元素
建立列表副本:
使用分片,new_list = old_list[:]
使用sorted(),new_list = sorted(old_list)
使用in关键字查找列表的一个特定值
使用index()得到在列表中一个特定值的位置
元组是一个与列表类似的集合,不能改变
建立双重列表:
使用嵌套的中括号
使用append(),并追加一个列表
建立单个列表,再合并这些列表
可以使用两个索引得到双重列表中的一个值
字典是键值对的集合
通过制定键和值得方式在字典中添加条目
通过键在字典中查找一个条目
"""
# 动手试一试
# 1. 写一个程序, 让用户提供 5 个名字。 程序要把这 5 个名字保存在一个列表中
enterNames = []
print("Enter 5 names: ")
for i in range(5):
enterNames.append(input())
outer = "The names are"
for i in enterNames:
outer = outer + " " + i
print(outer)
# 2. 修改第 1 题的程序, 要求不仅显示原来的名字列表, 还要显示出排序后的列表。
sortedNames = sorted(enterNames)
print(sortedNames)
sortedNames.sort(reverse=True)
print(sortedNames)
# 3. 修改第 1 题的程序, 要求只显示用户键入的第 3 个名字
for i in enterNames:
if i == 2:
print("THe third name you entered is: ",enterNames[i])
# 4. 修改第 1 题的程序, 让用户替换其中一个名字。 用户应该能选择要替换哪个
# 名字, 然后键入新名字
replaceIndex = int(input("Replace one name. Which one? (1-5): ")) - 1
newName = input("New name: ")
outer = "The names are " + enterNames[replaceIndex]
print(outer)
# 5. 编写一个字典程序, 让用户可以添加单词和定义, 然后可以查找这些单词。
# 确保当要查找的单词不存在时, 用户能够知晓。
wordDict = {}
order = input("Add or look up a word (a/l)? ")
if order == 'a':
newKey = input("Type the word: ")
newValue = input("Type the definition: ")
wordDict[newKey] = newValue
print("Word added!")
elif order == 'l':
checkKey = input("Type the word: ")
if checkKey in wordDict:
print(wordDict[checkKey])
else:
print("That word isn't in the dictionary yet.")
elif order == 'q':
break

3.13 Unit Thirteen 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# 函数
# 创建和使用函数
def printAddress():
print("Warren Sande")
print("123 Main Street")
print("Ottawa, Ontario, Canada")
print("K2M 2E9")
print()
printAddress()
print("Done the function")
# 希望在程序的不同位置打印地址,而不是全部都一次完成,使用循环实现不了
# 每次函数运行时可以让它有不同的表现
# 向函数传递参数
def printAddress2(name):
print(name)
print("123 Main Street")
print("Ottawa, Ontario, Canada")
print("K2M 2E9")
print()
printAddress2("Carter Sande")
# 两个参数的函数
def printAddress3(name,houseNum):
print(name)
print(houseNum)
print("123 Main Street")
print("Ottawa, Ontario, Canada")
print("K2M 2E9")
print()
printAddress3("Jack Black","45")
# 创建和使用带有返回值的函数
def calculate(price,tax_rate):
taxTotal = price + (price * tax_rate)
return taxTotal
user_price = float(input("Enter a price: "))
totalPrice = calculate(user_price,0.06)
print("price = ",user_price," Total price = ",totalPrice)
# 变量作用域
# 程序中使用(或者可以使用)变量的部分称为这个变量的作用域
# 局部变量
# price,tax_rate,taxTotal变量是calculate函数中的局部变量
# 全部变量
# 可以在程序的任何地方使用这些变量
# 尝试在函数内部修改一个全局变量
def calculate2(price,tax_rate):
total = price + (price * tax_rate)
my_price = 1000 # 局部变量
print("my_price (inside function) = ",my_price)
return total
my_price = float(input("Enter a price: ")) # 全局变量
totalPrice = calculate2(my_price,0.06)
print("price = ",my_price," Total price = ",totalPrice)
print("my_price (outside function) = ",my_price)
# 强制为全局
# 使用global关键字,创建或使用一个全局变量
def calculate3(price,tax_rate):
total = price + (price * tax_rate)
global my_price # 强制为全局
print("my_price (inside function) = ",my_price)
return total
my_price = float(input("Enter a price: ")) # 全局变量
totalPrice = calculate3(my_price,0.06)
print("price = ",my_price," Total price = ",totalPrice)
print("my_price (outside function) = ",my_price)
"""
你学到了什么
什么是函数
什么是参数(argument,parameter)
传递一个参数
传递多个参数
返回一个值
变量作用域
强制为全局
"""
"""
测试题
使用def关键字创建函数
使用函数名加括号来调用函数
函数可以有无数个参数,如果多达四五个,可以用列表来承载
使用return关键字返回
函数运行结束后,函数中的局部变量会删除
"""
# 动手试一试
# 1. 用大写字母打印carter
def printCarter():
print(" CCCC A RRRRR TTTTTTT EEEEEE RRRRR ")
print(" C C A A R R T E R R ")
print("C A A R R T EEEE R R ")
print("C AAAAAAA RRRRR T E RRRRR ")
print(" C C A A R R T E R R ")
print(" CCCC A A R R T EEEEEE R R ")
printCarter()
# 2. 打印输入的人名、地址、街道、城市、省份、邮局编码、国家
message = []
message.append(input("Enter name: "))
message.append(input("Enter address: "))
message.append(input("Enter street: "))
message.append(input("Enter city: "))
message.append(input("Enter province: "))
message.append(input("Enter postalcode: "))
message.append(input("Enter nation: "))
def printMessage(message):
print("The name:",message[0],"\nThe address:",message[1],
"\nThe street:",message[2],"\nThe city:",message[3],
"\nThe province:",message[4],"\nThe postalcode:",message[5],
"\nThe nation:",message[6])
printMessage(message)
# 3. 强制为全局
# 4. 计算零钱总面值,包括五分币,二分币,一分币
def totalPocket():
quarters = int(input("quarters: "))
dimes = int(input("dimes: "))
nickels = int(input("nickels: "))
pennies = int(input("pennies: "))
total = quarters * 0.25 + dimes * 0.1 + \
nickels * 0.05 + pennies * 0.01
print("total is",total)
totalPocket()

Unit Fourteen 对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
# 对象
# 如何描述-属性(attribute)或特性(property)
# 可以怎样操作-方法(method)
# 利用对象,可以把一个东西的属性(信息)和方法(动作)收集起来
# 创建对象
# 定义对象属性和动作(构建蓝图)-类
# 使用类建立一个真正的对象(这个类的一个实例)
# 属性并不属于类,它们属于各个实例,每个实例可以有不同的属性
class Ball:
"""docstring for Ball"""
def bounce(self):
if self.direction == 'down':
self.direction = 'up'
myBall = Ball()
myBall.direction = 'down'
myBall.color = 'green'
myBall.size = 'small'
print("I just created a ball.")
print("My ball is",myBall.size)
print("My ball is",myBall.color)
print("My ball's direction is",myBall.direction)
print("Now I'm going to bounce the ball.")
print()
myBall.bounce()
print("Now the ball's direction is",myBall.direction)
# 初始化对象
# 增加一个特殊方法-__init__()方法
class Ball2(object):
"""docstring for Ball2"""
def __init__(self, color, size, direction):
self.color = color
self.size = size
self.direction = direction
def bounce(self):
if self.direction == 'down':
self.direction = 'up'
myBall2 = Ball2('red','normal','down')
print("I just created a ball.")
print("My ball is",myBall2.size)
print("My ball is",myBall2.color)
print("My ball's direction is",myBall2.direction)
print("Now I'm going to bounce the ball.")
print()
myBall2.bounce()
print("Now the ball's direction is",myBall2.direction)
# 使用__str__()改变打印对象的方式
# 默认打印:
# 实例在那里定义
# 类名
# 存储实例的内存位置
# 覆写__str__()
class Ball3(object):
"""docstring for Ball3"""
def __init__(self, color, size, direction):
self.color = color
self.size = size
self.direction = direction
def __str__(self):
msg = "Hi, I'm a " + self.size + \
" " + self.color + " ball!"
return msg
myBall3 = Ball3('blue','big','up')
print(myBall3)
# 实例引用
# self参数会告诉方法哪个对象调用它
# self这个名字没有特殊含义,一个约定
class people():
"""docstring for peopel"""
def __init__(self, name):
self.name = name
def outer(self):
print(self.name)
warrens = people("Tom")
warrens.outer()
people.outer(warrens)
# 多态
# 同一个方法,不同的行为
class Triangle():
"""docstring for Triangle"""
def __init__(self, width, height):
self.width = width
self.height = height
def getArea(self):
area = self.width * self.height / 2
return area
class Square():
"""docstring for Square"""
def __init__(self, size):
self.size = size
def getArea(self):
area = self.size * self.size
return area
myTriangle = Triangle(4,5)
mySquare = Square(7)
print(myTriangle.getArea())
print(mySquare.getArea())
# 继承
# 从其他类继承属性或方法的类-派生类或子类
# 组织程序想法-代码桩(code stub)
# pass关键字-占位符
class GameObject():
"""docstring for GameObject"""
def __init__(self, name):
self.name = name
def pickUp(self,player):
pass
# put code here to add the object
# to the player's collection
class Coin(GameObject):
"""docstring for Coin"""
def __init__(self, value):
GameObject.__init__(self,'coin')
self.value = value
def spend(self,buyer,seller):
pass
# put code hear to remove the coin
# from the buyer's money and
# add it to the seller's money
# 定义HotDog类
class HotDog():
"""docstring for HotDog"""
def __init__(self):
# 烧烤时间对应生熟程度 0~3 生;>3 半生不熟;>5 熟;>8 木炭
self.cooked_level = 0
self.cooked_string = "Raw" # 描述生熟程度
self.condiments = [] # 配料列表
def cook(self,time):
# 加热时间
self.cooked_level = self.cooked_level + time
if self.cooked_level > 8:
self.cooked_string = "Charcoal"
elif self.cooked_level > 5:
self.cooked_string = "Well-done"
elif self.cooked_level > 3:
self.cooked_string = "Medium"
else:
self.cooked_string = "Raw"
def __str__(self):
msg = "hot dog"
if len(self.condiments) > 0:
msg = msg + " with "
for i in self.condiments:
msg = msg + i + ", "
msg = msg.strip(", ")
msg = self.cooked_string + " " + msg + "."
return msg
def addCondiment(self,condiment):
self.condiments.append(condiment)
# 检测HotDog()属性
myHotDog = HotDog()
print(myHotDog.cooked_level)
print(myHotDog.cooked_string)
print(myHotDog.condiments)
# 检测HotDog().cook()
print("Now, I'm going to cook the hot dog.")
print("Cooking hot dog for 4 minutes...")
myHotDog.cook(4)
print(myHotDog)
print("Cooking hot dog for 3 more minutes...")
myHotDog.cook(3)
print(myHotDog)
print("What happens if I cook it for 10 more minutes?")
myHotDog.cook(10)
print(myHotDog)
print("Now, I'm going to add some stuff on my hot dog.")
myHotDog.addCondiment("ketchup")
myHotDog.addCondiment("mustard")
print(myHotDog)
"""
你学到什么
什么是对象
属性和方法
什么是类
创建类的一个实例
特殊方法__init__(),__str__()
多态
继承
代码桩
"""
"""
测试题
定义一个新的对象类型时用class关键字
对象的描述是属性
对象的操作是方法
类是对象的定义或蓝图,实例是从这个蓝图建立对象
方法中实例引用通常用self
多态,同一个方法,不同的行为
继承,子类得到父类的属性和方法,还可以有父类没有的属性和方法
"""
# 动手试一试
# 1.
class BankAccount():
"""docstring for BankAccount"""
def __init__(self, name, account, balance):
self.name = name
self.account = account
self.balance = balance
def outer(self):
print("The account name:",self.name,
"\nThe account number:",self.account,
"\nThe balance:",self.balance)
myName = input("Enter account name: ")
myAccount = int(input("Enter account number: "))
myBalance = float(input("Enter balance: "))
myAccount = BankAccount(myName,myAccount,myBalance)
myAccount.outer()
# 2.
class InterestAccount(BankAccount):
"""docstring for InterestAccount"""
def __init__(self, name, account, balance, interest_rate):
BankAccount.__init__(self,name,account,balance)
self.interest_rate = float(interest_rate)
def addInterest(self):
self.balance = self.balance + self.balance * self.interest_rate
def outerbalance(self):
print(self.balance)
myInterestRate = float(input("Enter interest rate: "))
myAccountInterest = InterestAccount(myName,myAccount,myBalance,myInterestRate)
# myAccountInterest.outer()
myAccountInterest.outerbalance()
# 测试参考代码
class BankAccount2():
"""docstring for BankAccount2"""
def __init__(self, acct_number, acct_name):
self.acct_number = acct_number
self.acct_name = acct_name
self.balance = 0.0
def displayBalance(self):
print("The account balance is:",self.balance)
def deposit(self, amount):
self.balance = self.balance + amount
print("You deposited",amount)
print("The new balance is:",self.balance)
def withdraw(self, amount):
if self.balance >= amount:
self.balance = self.balance - amount
print("You withdraw",amount)
print("The new balance is:",self.balance)
else:
print("You tried to withdraw",amount)
print("The account balance is:",self.balance)
print("Withdrawal denied. Not enough funds.")
myAccount2 = BankAccount2(234,"Warren Sande")
print("Account name:",myAccount2.acct_name)
print("Account number:",myAccount2.acct_number)
myAccount2.displayBalance()
myAccount2.deposit(34.52)
myAccount2.withdraw(12.25)
myAccount2.withdraw(30.18)
class InterestAccount2(BankAccount2):
"""docstring for InterestAccount2"""
def __init__(self, acct_number, acct_name, rate):
BankAccount2.__init__(self, acct_number, acct_name)
self.rate = rate
def addInterest(self):
interest = self.balance * self.rate
print("adding interest to the account,",self.rate * 100, "percent.")
self.deposit(interest)
myAccount2 = InterestAccount2(234,"Warren Sande",0.11)
print("Account name:",myAccount2.acct_name)
print("Account number:",myAccount2.acct_number)
myAccount2.displayBalance()
myAccount2.deposit(34.52)
myAccount2.addInterest()
Unit Fifteen 模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# 模块
# 文件会更小
# 能在很多程序中使用
# 并不是所有模块都要使用
# 使用模块
# 指定在其他模块中定义的函数是必须具体
import my_module
celsius = float(input("Enter a temperature in Celsius: "))
fahrenheit = my_module.c_to_f(celsius)
print("That's",fahrenheit,"degrees Fahrenheit.")
# 命名空间
# 较大命名空间-全局命名空间
# 较小命名空间-局部命名空间
# 导入命名空间
# 方法一
# 指定了命名空间以及函数名
# fahrenheit = my_module.c_to_f(celsius)
# 方法二
# 用from导入
# from StephenLeacock import Fred
# 标准模块
# time - 获取计算机时钟信息
# sleep() - 增加一个延时
import time
print("How")
time.sleep(0.2)
print("are")
time.sleep(0.2)
print("you")
time.sleep(0.2)
print("today?")
from time import sleep
print("Hello, talk to you again in 5 seconds ...")
sleep(0.5)
print("Hi again")
# 不知道需要模块中的哪些名字,可以使用星号(*)将
# 所有名字都导入我们的命名空间。
# 如果在程序中创建一个名字,它与导入模块中的一个名字相同。
# 就会出现冲突
# random - 生成随机数
# randint() - 在区间取整数
# random() - 介于0到1之间的数
import random
print(random.randint(0,100))
print(random.random())
print(random.random()*10)
"""
学到了什么
什么是模块
创建模块
在另一个程序中使用模块
命名空间
局部和全局命名空间和变量
把其他模块中的名字包含到你的命名空间中
"""
"""
测试题
模块好处:重复使用,文件体积小,不同功能不同实现
创建模块在别的python文件保存
使用import引入
导入模块与导入命名空间是一样的
导入模块方式:import ** 和 from ** import *
"""
# 动手试一试
# 1. 大写字母打印
from my_module import printCarter
printCarter()
# 2.
from my_module import c_to_f
celsius = float(input("Enter a temperature in Celsius: "))
fahrenheit = c_to_f(celsius)
print("That's",fahrenheit,"degrees Fahrenheit.")
# 3. 生成1到20之间的5个随机整数列表
outer_int = []
from random import randint
for i in range(5):
outer_int.append(randint(1,20))
print(outer_int)
# 4. 工作30秒,每3秒打印一个随机小数
from random import random
for i in range(10):
sleep(3)
print(random())

my_module.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# this is the file "my_module.py"
# we're going to use it in another program
def c_to_f(celsius):
fahrenheit = celsius * 9.0 / 5 + 32
return fahrenheit
def printCarter():
print(" CCCC A RRRRR TTTTTTT EEEEEE RRRRR ")
print(" C C A A R R T E R R ")
print("C A A R R T EEEE R R ")
print("C AAAAAAA RRRRR T E RRRRR ")
print(" C C A A R R T E R R ")
print(" CCCC A A R R T EEEEEE R R ")