高级编程技术 作业6

##11-1 城市和国家 ：编写一个函数，它接受两个形参：一个城市名和一个国家名。这个函数返回一个格式为 City, Country 的字符串，如 Santiago, Chile 。将这个函数存储在一个名为 city_functions.py 的模块中。

创建一个名为 test_cities.py 的程序，对刚编写的函数进行测试（别忘了，你需要导入模块 unittest 以及要测试的函数）。编写一个名为 test_city_country() 的方法，核实使用类似于 ‘santiago’ 和 ‘chile’ 这样的值来调用前述函数时，得到的字符串是正确的。运行 test_cities.py ，确认测试 test_city_country() 通过了。

1
2
3
4
5
6
7
8
9
10
11
import unittest

def city_country(city, country):
    return "{}, {}".format(city, country)

class CityCountryTestCase(unittest.TestCase):
    def test_city_country(self):
        t = city_country('santigo', 'chile')
        self.assertEqual(t, 'santigo, chile')

unittest.main()

11-2 人口数量 ：修改前面的函数，使其包含第三个必不可少的形参 population ，并返回一个格式为 City, Country - population xxx 的字符串，如 Santiago, Chile - population 5000000 。运行 test_cities.py ，确认测试 test_city_country() 未通过。

修改上述函数，将形参 population 设置为可选的。再次运行 test_cities.py ，确认测试 test_city_country() 又通过了。
再编写一个名为 test_city_country_population() 的测试，核实可以使用类似于 ‘santiago’ 、 ‘chile’ 和 ‘population=5000000’ 这样的值来调用这个函数。再次运行 test_cities.py ，确认测试 test_city_country_population() 通过了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import unittest

def city_country(city, country, population=0):
    if population == 0:
        return "{}, {}".format(city, country)
    else:
        return "{}, {} - population {}".format(city, country, population)

class CityCountryTestCase(unittest.TestCase):
    def test_city_country(self):
        t = city_country('santigo', 'chile')
        self.assertEqual(t, 'santigo, chile')


    def test_city_country_population(self):
        t = city_country('santigo', 'chile', 5000000)
        self.assertEqual(t, 'santigo, chile - population 5000000')

unittest.main()

11-3 雇员 ：编写一个名为 Employee 的类，其方法 init() 接受名、姓和年薪，并将它们都存储在属性中。编写一个名为 give_raise() 的方法，它默认将年薪增加 5000 美元，但也能够接受其他的年薪增加量。

为 Employee 编写一个测试用例，其中包含两个测试方法： test_give_default_raise() 和 test_give_custom_raise() 。使用方法 setUp() ，以免在每个测试方法中都创建新的雇员实例。运行这个测试用例，确认两个测试都通过了。

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
import unittest
class Employee:
    def __init__(self, first_name, last_name, salary):
        self.first_name = first_name
        self.last_name = last_name
        self.salary = salary

    def give_raise(self, salary=5000):
        self.salary += salary

class EmployeeTestCase(unittest.TestCase):
    def setUp(self):
        self.employee = Employee('a', 'b', 2333)

    def test_give_default_raise(self):
        i = self.employee.salary
        self.employee.give_raise()
        self.assertEqual(self.employee.salary, i + 5000)

    def test_give_custom_raise(self):
        i = self.employee.salary
        self.employee.give_raise(666)
        self.assertEqual(self.employee.salary, i + 666)

unittest.main()

## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


## 

1
2


高级编程技术 作业5

##9-1 餐馆 ：创建一个名为 Restaurant 的类，其方法 init() 设置两个属性： restaurant_name 和 cuisine_type 。创建一个名为 describe_restaurant() 的方法和一个名为 open_restaurant() 的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。

根据这个类创建一个名为 restaurant 的实例，分别打印其两个属性，再调用前述两个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Restaurant():

    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type

    def describe_restaurant(self):
        print(self.restaurant_name)
        print(self.cuisine_type)

    def open_restaurant(self):
        print("Restaurant is Available")

restaurant = Restaurant('Hi', "What?")
restaurant.describe_restaurant()
restaurant.open_restaurant()

##9-2 三家餐馆 ：根据你为完成练习 9-1 而编写的类创建三个实例，并对每个实例调用方法 describe_restaurant() 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Restaurant():

    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type

    def describe_restaurant(self):
        print(self.restaurant_name)
        print(self.cuisine_type)

    def open_restaurant(self):
        print("Restaurant is Available")

a = Restaurant('a', "aa")
b = Restaurant('b', "bb")
c = Restaurant('c', "cc")
a.describe_restaurant()
b.describe_restaurant()
c.describe_restaurant()

##9-3 用户 ：创建一个名为 User 的类，其中包含属性 first_name 和 last_name ，还有用户简介通常会存储的其他几个属性。在类 User 中定义一个名为 describe_user() 的方法，它打印用户信息摘要；再定义一个名为 greet_user() 的方法，它向用户发出个性化的问候。

创建多个表示不同用户的实例，并对每个实例都调用上述两个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class User():

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def describe_user(self):
        print(self.first_name)
        print(self.last_name)

    def greet_user(self):
        print("Hello,", self.first_name, self.last_name)

a = User('a', 'aa')
b = User('b', 'bb')
c = User('c', 'cc')
a.describe_user()
a.greet_user()
b.describe_user()
b.greet_user()
c.describe_user()
c.greet_user()

##9-4 就餐人数 ：在为完成练习 9-1 而编写的程序中，添加一个名为 number_served 的属性，并将其默认值设置为 0 。根据这个类创建一个名为 restaurant 的实例；打印有多少人在这家餐馆就餐过，然后修改这个值并再次打印它。

添加一个名为 set_number_served() 的方法，它让你能够设置就餐人数。调用这个方法并向它传递一个值，然后再次打印这个值。
添加一个名为 increment_number_served() 的方法，它让你能够将就餐人数递增。调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。

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
class Restaurant():

    def __init__(self, restaurant_name, cuisine_type, number_served=0):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = number_served

    def describe_restaurant(self):
        print(self.restaurant_name)
        print(self.cuisine_type)

    def open_restaurant(self):
        print("Restaurant is Available")

    def set_number_served(self, number_served):
        self.number_served = number_served

    def increment_number_served(self, number_served):
        self.number_served += number_served

restaurant = Restaurant('a', 'b')
print(restaurant.number_served)
restaurant.number_served = 1
print(restaurant.number_served)
restaurant.set_number_served(2)
print(restaurant.number_served)
restaurant.increment_number_served(3)
print(restaurant.number_served)

##9-5 尝试登录次数 ：在为完成练习 9-3 而编写的 User 类中，添加一个名为 login_attempts 的属性。编写一个名为 increment_login_attempts() 的方法，它将属性 login_attempts 的值加 1 。再编写一个名为 reset_login_attempts() 的方法，它将属性 login_attempts 的值重置为 0 。

根据 User 类创建一个实例，再调用方法 increment_login_attempts() 多次。打印属性 login_attempts 的值，确认它被正确地递增；然后，调用方法 reset_login_attempts() ，并再次打印属性 login_attempts 的值，确认它被重置为 0 。

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
class User():

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name
        self.login_attempts = 0

    def describe_user(self):
        print(self.first_name)
        print(self.last_name)

    def greet_user(self):
        print("Hello,", self.first_name, self.last_name)

    def increment_login_attempts(self):
        self.login_attempts += 1

    def reset_login_attempts(self):
        self.login_attempts = 0

u = User('a', 'b')
for i in range(5):
    u.increment_login_attempts()
    print(u.login_attempts)
u.reset_login_attempts()
print(u.login_attempts)

##9-6 冰淇淋小店 ：冰淇淋小店是一种特殊的餐馆。编写一个名为 IceCreamStand 的类，让它继承你为完成练习 9-1 或练习 9-4 而编写的 Restaurant 类。这两个版本的 Restaurant 类都可以，挑选你更喜欢的那个即可。添加一个名为 flavors 的属性，用于存储一个由各种口味的冰淇淋组成的列表。编写一个显示这些冰淇淋的方法。创建一个 IceCreamStand 实例，并调用这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Restaurant():

    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type

    def describe_restaurant(self):
        print(self.restaurant_name)
        print(self.cuisine_type)

    def open_restaurant(self):
        print("Restaurant is Available")

class IceCreamStand(Restaurant):
    def __init__(self, restaurant_name, cuisine_type, flavors):
        super().__init__(restaurant_name, cuisine_type)
        self.flavors = flavors

    def show_flavors(self):
        print(self.flavors)

i = IceCreamStand('a', 'b', ['c', 'd', 'e'])
i.show_flavors()

##9-7 管理员 ：管理员是一种特殊的用户。编写一个名为 Admin 的类，让它继承你为完成练习 9-3 或练习 9-5 而编写的 User 类。添加一个名为 privileges 的属性，用于存储一个由字符串（如 “can add post” 、 “can delete post” 、 “can ban user” 等）组成的列表。编写一个名为 show_privileges() 的方法，它显示管理员的权限。创建一个 Admin 实例，并调用这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class User():

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def describe_user(self):
        print(self.first_name)
        print(self.last_name)

    def greet_user(self):
        print("Hello,", self.first_name, self.last_name)

class Admin(User):
    def __init__(self, first_name, last_name):
        super().__init__(first_name, last_name)
        self.privileges = ["can add post", "can delete post", "can ban user"]

    def show_privileges(self):
        print(self.privileges)

a = Admin('a', 'b')
a.show_privileges()

##9-8 权限 ：编写一个名为 Privileges 的类，它只有一个属性 —— privileges ，其中存储了练习 9-7 所说的字符串列表。将方法 show_privileges() 移到这个类中。在 Admin 类中，将一个 Privileges 实例用作其属性。创建一个 Admin 实例，并使用方法 show_privileges() 来显示其权限。

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
class Privileges():
    def __init__(self):
        self.privileges = ["can add post", "can delete post", "can ban user"]

    def show_privileges(self):
        print(self.privileges)

class User():

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def describe_user(self):
        print(self.first_name)
        print(self.last_name)

    def greet_user(self):
        print("Hello,", self.first_name, self.last_name)

class Admin(User):
    def __init__(self, first_name, last_name):
        super().__init__(first_name, last_name)
        self.privileges = Privileges()

    def show_privileges(self):
        self.privileges.show_privileges()

a = Admin('a', 'b')
a.show_privileges()

##9-9 电瓶升级 ：在本节最后一个 electric_car.py 版本中，给 Battery 类添加一个名为 upgrade_battery() 的方法。这个方法检查电瓶容量，如果它不是 85 ，就将它设置为 85 。创建一辆电瓶容量为默认值的电动汽车，调用方法 get_range() ，然后对电瓶进行升级，并再次调用 get_range() 。你会看到这辆汽车的续航里程增加了。

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
class Battery:
    """ 一次模拟电动汽车电瓶的简单尝试 """

    def __init__(self, battery_size=70):
        """ 初始化电瓶的属性 """
        self.battery_size = battery_size

    def describe_battery(self):
        """ 打印一条描述电瓶容量的消息 """
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

    def get_range(self):
        """ 打印一条消息，指出电瓶的续航里程 """
        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
        message = "This car can go approximately " + str(range)
        message += " miles on a full charge."
        print(message)

    def upgrade_battery(self):
        if self.battery_size != 85:
            self.battery_size = 85


class Car:
    """ 一次模拟汽车的简单尝试 """

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        self.odometer_reading += miles


class ElectricCar(Car):
    """ 电动汽车的独特之处 """

    def __init__(self, make, model, year):
        """ 初始化父类的属性 """
        super().__init__(make, model, year)
        self.baterry = Battery()

e = ElectricCar('a', 'b', 'c')
e.baterry.get_range()
e.baterry.upgrade_battery()
e.baterry.get_range()

##9-10 导入 Restaurant 类 ：将最新的 Restaurant 类存储在一个模块中。在另一个文件中，导入 Restaurant 类，创建一个 Restaurant 实例，并调用 Restaurant 的一个方法，以确认 import 语句正确无误。

1
2
3
4
5
6
7
8
9
from restaurant import Restaurant
restaurant = Restaurant('a', 'b')
print(restaurant.number_served)
restaurant.number_served = 1
print(restaurant.number_served)
restaurant.set_number_served(2)
print(restaurant.number_served)
restaurant.increment_number_served(3)
print(restaurant.number_served)

##9-11 导入 Admin 类 ：以为完成练习 9-8 而做的工作为基础，将 User 、 Privileges 和 Admin 类存储在一个模块中，再创建一个文件，在其中创建一个 Admin 实例并对其调用方法 show_privileges() ，以确认一切都能正确地运行。

1
2
3
from admin import Admin
a = Admin('a', 'b')
a.show_privileges()

##9-12 多个模块 ：将 User 类存储在一个模块中，并将 Privileges 和 Admin 类存储在另一个模块中。再创建一个文件，在其中创建一个 Admin 实例，并对其调用方法 show_privileges() ，以确认一切都依然能够正确地运行。

1
2
3
4
from user import User
from admin import Privileges, Admin
a = Admin('a', 'b')
a.show_privileges()

##9-15 Python Module of the Week ：要了解 Python 标准库，一个很不错的资源是网站 Python Module of the Week 。请访问 http://pymotw.com/ 并查看其中的目录，在其中找一个你感兴趣的模块进行探索，或阅读模块 collections 和 random 的文档。

1
https://pymotw.com/3/re/index.html

##10-1 Python 学习笔记 ：在文本编辑器中新建一个文件，写几句话来总结一下你至此学到的 Python 知识，其中每一行都以 “In Python you can” 打头。将这个文件命名为learning_python.txt ，并将其存储到为完成本章练习而编写的程序所在的目录中。编写一个程序，它读取这个文件，并将你所写的内容打印三次：第一次打印时读取整个文件；第二次打印时遍历文件对象；第三次打印时将各行存储在一个列表中，再在 with 代码块外打印它们。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
file = 'learning_python.txt'
with open(file, 'r', encoding='UTF-8') as f:
    m = f.read()
    print(m)

with open(file, 'r', encoding='UTF-8') as f:
    for line in f:
        print(line)

with open(file, 'r', encoding='UTF-8') as f:
    ml = f.readlines()
    
for i in ml:
    print(i)

##10-2 C 语言学习笔记 ：可使用方法 replace() 将字符串中的特定单词都替换为另一个单词。

读取你刚创建的文件 learning_python.txt 中的每一行，将其中的 Python 都替换为另一门语言的名称，如 C 。将修改后的各行都打印到屏幕上。

1
2
3
4
5
6
file = 'learning_python.txt'
with open(file, 'r', encoding='UTF-8') as f:
    ml = f.readlines()
for i in ml:
    i = i.replace('Python', 'C')
    print(i)

##10-3 访客 ：编写一个程序，提示用户输入其名字；用户作出响应后，将其名字写入到文件 guest.txt 中。

1
2
3
n = input("Enter your name:\n")
with open('guest.txt ', 'w') as f:
    f.write(n)

##10-4 访客名单 ：编写一个 while 循环，提示用户输入其名字。用户输入其名字后，在屏幕上打印一句问候语，并将一条访问记录添加到文件 guest_book.txt 中。确保这个文件中的每条记录都独占一行。

1
2
3
4
5
with open('guest.txt ', 'w') as f:
    while True:
        n = input("Enter your name:\n")
        print("Hello, {}!".format(n))
        f.write(n + '\n')

##10-5 关于编程的调查 ：编写一个 while 循环，询问用户为何喜欢编程。每当用户输入一个原因后，都将其添加到一个存储所有原因的文件中。

1
2
3
4
with open('reasons.txt ', 'w+') as f:
    while True:
        n = input("Enter your reason:\n")
        f.write(n + '\n')

##10-6 加法运算 ：提示用户提供数值输入时，常出现的一个问题是，用户提供的是文本而不是数字。在这种情况下，当你尝试将输入转换为整数时，将引发 TypeError 异常。编写一个程序，提示用户输入两个数字，再将它们相加并打印结果。在用户输入的任何一个值不是数字时都捕获 TypeError 异常，并打印一条友好的错误消息。对你编写的程序进行测试：先输入两个数字，再输入一些文本而不是数字。

1
2
3
4
5
6
a = input('Enter the first number:\n')
b = input('Enter the second number:\n')
try:
    print(int(a) + int(b))
except TypeError as e:
    print("TypeError!\n", e)

##10-7 加法计算器 ：将你为完成练习 10-6 而编写的代码放在一个 while 循环中，让用户犯错（输入的是文本而不是数字）后能够继续输入数字。

1
2
3
4
5
6
7
while True:
    a = input('Enter the first number:\n')
    b = input('Enter the second number:\n')
    try:
        print(int(a) + int(b))
    except TypeError as e:
        print("TypeError!\n", e)

##10-8 猫和狗 ：创建两个文件 cats.txt 和 dogs.txt ，在第一个文件中至少存储三只猫的名字，在第二个文件中至少存储三条狗的名字。编写一个程序，尝试读取这些文件，并将其内容打印到屏幕上。将这些代码放在一个 try-except 代码块中，以便在文件不存在时捕获 FileNotFound 错误，并打印一条友好的消息。将其中一个文件移到另一个地方，并确认 except 代码块中的代码将正确地执行。

1
2
3
4
5
6
7
8
9
10
11
12
f1 = 'cats.txt '
f2 = 'dogs.txt'
try:
    with open(f1, 'r') as f:
        print(f.read())
except FileNotFoundError as e:
    print(e)
try:
    with open(f2, 'r') as f:
        print(f.read())
except FileNotFoundError as e:
    print(e)

##10-9 沉默的猫和狗 ：修改你在练习 10-8 中编写的 except 代码块，让程序在文件不存在时一言不发。

1
2
3
4
5
6
7
8
9
10
11
f1 = 'cats.txt '
f2 = 'dogs.txt'
try:
    with open(f1, 'r') as f:
        print(f.read())
except FileNotFoundError as e:

try:
    with open(f2, 'r') as f:
        print(f.read())
except FileNotFoundError as e:

##10-10 常见单词 ：访问项目 Gutenberg （ http://gutenberg.org/ ），并找一些你想分析的图书。下载这些作品的文本文件或将浏览器中的原始文本复制到文本文件中。你可以使用方法 count() 来确定特定的单词或短语在字符串中出现了多少次。例如，下面的代码计算 ‘row’ 在一个字符串中出现了多少次：

编写一个程序，它读取你在项目 Gutenberg 中获取的文件，并计算单词 ‘the’ 在每个文件中分别出现了多少次。

1
2
3
4
5
6
f1 = 'download.txt '
try:
    with open(f1, 'r') as f:
        print(f.read().lower().count('the'))
except FileNotFoundError as e:
    print(e)

##10-11 喜欢的数字 ：编写一个程序，提示用户输入他喜欢的数字，并使用 json.dump() 将这个数字存储到文件中。再编写一个程序，从文件中读取这个值，并打印消息 “I know your favorite number! It’s _.” 。

1
2
3
4
5
6
7
8
import json
f1 = 'num.json'
n = input("Enter a number:\n")
with open(f1, 'w') as f:
    json.dump(n, f)
with open(f1) as f:
    nn = json.load(f)
print("I know your favorite number! It's {}.".format(nn))

##10-12 记住喜欢的数字 ：将练习 10-11 中的两个程序合而为一。如果存储了用户喜欢的数字，就向用户显示它，否则提示用户输入他喜欢的数字并将其存储到文件中。运行这个程序两次，看看它是否像预期的那样工作。

1
2
3
4
5
6
7
8
9
10
11
import json
f1 = 'num.json'
try:
    with open(f1) as f:
        nn = json.load(f)
    print("I know your favorite number! It's {}.".format(nn))
except FileNotFoundError as e:
    
n = input("Enter a number:\n")
with open(f1, 'w') as f:
    json.dump(n, f)

##10-13 验证用户 ：最后一个 remember_me.py 版本假设用户要么已输入其用户名，要么是首次运行该程序。我们应修改这个程序，以应对这样的情形：当前和最后一次运行该程序的用户并非同一个人。

为此，在 greet_user() 中打印欢迎用户回来的消息前，先询问他用户名是否是对的。如果不对，就调用get_new_username() 让用户输入正确的用户名。

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
import json


def get_stored_username():
    """ 如果存储了用户名，就获取它 """
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
            username = json.load(f_obj)
    except FileNotFoundError:
        return None
    else:
        return username


def get_new_username():
    """ 提示用户输入用户名 """

    username = input("What is your name? ")
    filename = 'username.json'
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
    return username


def greet_user():
    """ 问候用户，并指出其名字 """
    a = input("What's your name?\n")
    if a == get_stored_username():
        username = get_stored_username()
        if username:
            print("Welcome back, " + username + "!")
        else:
            username = get_new_username()
        print("We'll remember you when you come back, " + username + "!")
    else:
        username = get_new_username()
        if username:
            print("Welcome back, " + username + "!")
        else:
            username = get_new_username()
        print("We'll remember you when you come back, " + username + "!")

greet_user()

##

高级编程技术 作业4

##7-1 汽车租赁 ：编写一个程序，询问用户要租赁什么样的汽车，并打印一条消息，如 “Let me see if I can find you a Subaru” 。

1
2
car = input("What kind of car do you want to rent?")
print("Let me see if I can find you a %s."%car)

##7-2 餐馆订位 ：编写一个程序，询问用户有多少人用餐。如果超过 8 人，就打印一条消息，指出没有空桌；否则指出有空桌。

1
2
3
4
5
num = int(input("How many people?\n"))
if num <= 8:
    print("Available.")
else:
    print("Not available.")

##7-3 10 的整数倍 ：让用户输入一个数字，并指出这个数字是否是 10 的整数倍。

1
2
3
4
5
num = int(input("Enter a bumber.\n"))
if num % 10 != 0:
    print("NO")
else:
    print("YES")

##7-4 比萨配料 ：编写一个循环，提示用户输入一系列的比萨配料，并在用户输入 ‘quit’ 时结束循环。每当用户输入一种配料后，都打印一条消息，说我们会在比萨中添加这种配料。

1
2
3
4
m = input("Enter material:\n")
while m != "quit":
    print("We will add %s to pizza."%m)
    m = input("Enter material:\n")

##7-5 电影票 ：有家电影院根据观众的年龄收取不同的票价：不到 3 岁的观众免费； 3~12 岁的观众为 10 美元；超过 12 岁的观众为 15 美元。请编写一个循环，在其中询问用户的年龄，并指出其票价。

1
2
3
4
5
6
7
8
9
10
m = input("How old are you?\n")
while m != "quit":
    n = int(m)
    if n < 3:
        print("Free.")
    elif n < 12:
        print("$10.")
    else:
        print("$15.")
    m = input("How old are you?\n")

7-6 三个出口 ：以另一种方式完成练习 7-4 或练习 7-5 ，在程序中采取如下所有做法。

  • 在 while 循环中使用条件测试来结束循环。
  • 使用变量 active 来控制循环结束的时机。
  • 使用 break 语句在用户输入 ‘quit’ 时退出循环。
1
2
3
4
5
6
7
8
9
10
active = input("How old are you?\n")
while active != "quit":
    n = int(active)
    if n < 3:
        print("Free.")
    elif n < 12:
        print("$10.")
    else:
        print("$15.")
    active = input("How old are you?\n")

##7-7 无限循环 ：编写一个没完没了的循环，并运行它（要结束该循环，可按 Ctrl +C ，也可关闭显示输出的窗口）。

1
2
while True:
    print("But it refuse.")

##7-8 熟食店 ：创建一个名为 sandwich_orders 的列表，在其中包含各种三明治的名字；再创建一个名为 finished_sandwiches 的空列表。遍历列表 sandwich_orders ，对于其中的每种三明治，都打印一条消息，如 I made your tuna sandwich ，并将其移到列表 finished_sandwiches 。所有三明治都制作好后，打印一条消息，将这些三明治列出来。

1
2
3
4
5
6
sandwich_orders = ['1', '2', '3']
finished_sandwiches = []
while len(sandwich_orders) > 0:
    finished_sandwiches.append(sandwich_orders[0])
    print("I made your %s sandwich."%sandwich_orders[0])
    del sandwich_orders[0]

##7-9 五香烟熏牛肉（ pastrami ）卖完了 ：使用为完成练习 7-8 而创建的列表 sandwich_orders ，并确保 ‘pastrami’ 在其中至少出现了三次。在程序开头附近添加这样的代码：打印一条消息，指出熟食店的五香烟熏牛肉卖完了；再使用一个 while 循环将列表 sandwich_orders 中的 ‘pastrami’ 都删除。确认最终的列表 finished_sandwiches 中不包含 ‘pastrami’ 。

1
2
3
4
5
6
7
8
9
sandwich_orders = ['1', '2', '3', 'pastrami', 'pastrami', 'pastrami']
finished_sandwiches = []
print("Pastrami is NOT available.")
while 'pastrami' in sandwich_orders:
    sandwich_orders.remove('pastrami')
while len(sandwich_orders) > 0:
    finished_sandwiches.append(sandwich_orders[0])
    print("I made your %s sandwich."%sandwich_orders[0])
    del sandwich_orders[0]

##7-10 梦想的度假胜地 ：编写一个程序，调查用户梦想的度假胜地。使用类似于 “If you could visit one place in the world, where would you go?” 的提示，并编写一个打印调查结果的代码块。

1
2
3
4
m = input("If you could visit one place in the world, where would you go?\n")
while m != "quit":
    print(m)
    m = input("If you could visit one place in the world, where would you go?\n")

##8-1 消息 ：编写一个名为 display_message() 的函数，它打印一个句子，指出你在本章学的是什么。调用这个函数，确认显示的消息正确无误。

1
2
3
4
def display_message():
    print("I learn function in python.")
display_message()
display_message()

##8-2 喜欢的图书 ：编写一个名为 favorite_book() 的函数，其中包含一个名为 title 的形参。这个函数打印一条消息，如 One of my favorite books is Alice in Wonderland 。调用这个函数，并将一本图书的名称作为实参传递给它。

1
2
3
def favorite_book(title):
    print("One of my favorite books is %s."%title)
favorite_book('Alice in Wonderland')

##8-3 T 恤 ：编写一个名为 make_shirt() 的函数，它接受一个尺码以及要印到 T 恤上的字样。这个函数应打印一个句子，概要地说明 T 恤的尺码和字样。使用位置实参调用这个函数来制作一件 T 恤；再使用关键字实参来调用这个函数。

1
2
3
4
def make_shirt(size, mes):
    print("Size is %s, message is %s."%(size, mes))
make_shirt('XL', 'UNDERTALE')
make_shirt(size='XL', mes='UNDERTALE')

##8-4 大号 T 恤 ：修改函数 make_shirt() ，使其在默认情况下制作一件印有字样 “I love Python” 的大号 T 恤。调用这个函数来制作如下 T 恤：一件印有默认字样的大号 T 恤、一件印有默认字样的中号 T 恤和一件印有其他字样的 T 恤（尺码无关紧要）。

1
2
3
4
5
def make_shirt(size='XL', mes='I love Python'):
    print("Size is %s, message is %s."%(size, mes))
make_shirt()
make_shirt('L')
make_shirt('XL', 'UNDERTALE')

##8-5 城市 ：编写一个名为 describe_city() 的函数，它接受一座城市的名字以及该城市所属的国家。这个函数应打印一个简单的句子，如 Reykjavik is in Iceland 。给用于存储国家的形参指定默认值。为三座不同的城市调用这个函数，且其中至少有一座城市不属于默认国家。

1
2
3
4
5
def describe_city(name, country='Hyrule'):
    print("%s is in %s."%(name, country))
describe_city('a')
describe_city('b')
describe_city('c', 'Wahaha')

##8-7 专辑 ：编写一个名为 make_album() 的函数，它创建一个描述音乐专辑的字典。这个函数应接受歌手的名字和专辑名，并返回一个包含这两项信息的字典。使用这个函数创建三个表示不同专辑的字典，并打印每个返回的值，以核实字典正确地存储了专辑的信息。

给函数 make_album() 添加一个可选形参，以便能够存储专辑包含的歌曲数。如果调用这个函数时指定了歌曲数，就将这个值添加到表示专辑的字典中。调用这个函数，并至少在一次调用中指定专辑包含的歌曲数。

1
2
3
4
5
6
7
8
9
def make_album(name, album, count=''):
    if count != '':
    	return {name: album, 'count': count}
    else:
        return {name: album}
for i, j in make_album('a', 'b').items():
    print("%s: %s"%(i, j))
for i, j in make_album('a', 'b', '123').items():
    print("%s: %s"%(i, j))

##8-8 用户的专辑 ：在为完成练习 8-7 编写的程序中，编写一个 while 循环，让用户输入一个专辑的歌手和名称。获取这些信息后，使用它们来调用函数 make_album() ，并将创建的字典打印出来。在这个 while 循环中，务必要提供退出途径。

1
2
3
4
5
6
7
8
9
10
11
12
def make_album(name, album, count=''):
    if count != '':
    	return {name: album, 'count': count}
    else:
        return {name: album}
m = input('Name: ')
n = input('Album: ')
while m != 'quit' and n != 'quit':
    for i, j in make_album(m, n).items():
    	print("%s: %s"%(i, j))
    m = input('Name: ')
	n = input('Album: ')

##8-9 魔术师 ：创建一个包含魔术师名字的列表，并将其传递给一个名为 show_magicians() 的函数，这个函数打印列表中每个魔术师的名字。

1
2
3
4
5
l = ['1', '2', '3']
def show_magicians(l):
    for i in l:
        print(i)
show_magicians(l)

##8-10 了不起的魔术师 ：在你为完成练习 8-9 而编写的程序中，编写一个名为 make_great() 的函数，对魔术师列表进行修改，在每个魔术师的名字中都加入字样 “the Great” 。调用函数 show_magicians() ，确认魔术师列表确实变了。

1
2
3
4
5
6
7
8
9
10
11
l = ['1', '2', '3']
def show_magicians(l):
    for i in l:
        print(i)
def make_great(l):
    i = 0
    while i < len(l):
        l[i] = 'the Great ' + l[i]
        i += 1
make_great(l)
show_magicians(l)

##8-11 不变的魔术师 ：修改你为完成练习 8-10 而编写的程序，在调用函数 make_great() 时，向它传递魔术师列表的副本。由于不想修改原始列表，请返回修改后的列表，并将其存储到另一个列表中。分别使用这两个列表来调用 show_magicians() ，确认一个列表包含的是原来的魔术师名字，而另一个列表包含的是添加了字样 “the Great” 的魔术师名字。

1
2
3
4
5
6
7
8
9
10
11
12
13
l = ['1', '2', '3']
def show_magicians(l):
    for i in l:
        print(i)
def make_great(l):
    i = 0
    while i < len(l):
        l[i] = 'the Great ' + l[i]
        i += 1
    return l
m = make_great(l[:])
show_magicians(l)
show_magicians(m)

##8-12 三明治 ：编写一个函数，它接受顾客要在三明治中添加的一系列食材。这个函数只有一个形参（它收集函数调用中提供的所有食材），并打印一条消息，对顾客点的三明治进行概述。调用这个函数三次，每次都提供不同数量的实参。

1
2
3
4
5
6
def foo(*m):
    for i in m:
        print(i)
foo('1')
foo('2', '3')
foo('4', '5', '6')

##8-13 用户简介 ：复制前面的程序 user_profile.py ，在其中调用 build_profile() 来创建有关你的简介；调用这个函数时，指定你的名和姓，以及三个描述你的键 - 值对。

1
2
3
4
5
6
7
8
9
10
11
12
13
def build_profile(first, last, **user_info):
	"""创建一个字典，其中包含我们知道的有关用户的一切"""
	profile = {}
	profile['first_name'] = first
	profile['last_name'] = last
	for key, value in user_info.items():
		profile[key] = value
	return profile
user_profile = build_profile('albert', 'einstein',
							 location='princeton',
							 field='physics',
                             sex='male')
print(user_profile)

##8-14 汽车 ：编写一个函数，将一辆汽车的信息存储在一个字典中。这个函数总是接受制造商和型号，还接受任意数量的关键字实参。这样调用这个函数：提供必不可少的信息，以及两个名称 — 值对，如颜色和选装配件。这个函数必须能够像下面这样进行调用：

1
2
3
4
5
6
7
8
def make_car(band, size, **info):
    p = {}
    p['band'] = band
    p['size'] = size
    for i, j in info.items():
        p[i] = j
    return p
car = make_car('subaru', 'outback', color='blue', tow_package=True)

##8-15 打印模型 ：将示例 print_models.py 中的函数放在另一个名为 printing_functions.py 的文件中；在 print_models.py 的开头编写一条 import 语句，并修改这个文件以使用导入的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# printing_functions.py
def print_models(unprinted_designs, completed_models):
	"""
	模拟打印每个设计，直到没有未打印的设计为止
	打印每个设计后，都将其移到列表 completed_models 中
	"""
	while unprinted_designs:
		current_design = unprinted_designs.pop()
		# 模拟根据设计制作 3D 打印模型的过程
		print("Printing model: " + current_design)
		completed_models.append(current_design)

def show_completed_models(completed_models):
	""" 显示打印好的所有模型 """
	print("\nThe following models have been printed:")
	for completed_model in completed_models:
		print(completed_model)

# print_models.py
from printing_functions import print_models, show_completed_models

##8-16 导入 ：选择一个你编写的且只包含一个函数的程序，并将这个函数放在另一个文件中。在主程序文件中，使用下述各种方法导入这个函数，再调用它：

1
2
3
4
5
import requests
from requests import api
from requests import api as a
import numpy as np
from requests import *

高级编程技术 作业3

5-1 条件测试 ：编写一系列条件测试；将每个测试以及你对其结果的预测和实际结果都打印出来。你编写的代码应类似于下面这样：

1
2
3
4
5
car = 'subaru'
print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')
print("\nIs car == 'audi'? I predict False.")
print(car == 'audi')
  • 详细研究实际结果，直到你明白了它为何为 True 或 False 。
  • 创建至少 10 个测试，且其中结果分别为 True 和 False 的测试都至少有 5 个。
1
2
3
4
5
6
7
8
9
10
11
12
def test(item, itemName, value):
    print("Is %s == '%s'? I predict True."%(itemName, item))
    print(True)
    print("\nIs %s == '%s'? I predict False."%(itemName, value))
    print(item == 'value')
car = 'subaru'
test(car, 'car', 'audi')
person = 'Link'
test(person, 'person', 'Zelda')
test(person, 'person', 'Mifa')
test(person, 'person', 'Sidon')
test(person, 'person', 'Dola')

##5-2 更多的条件测试 ：你并非只能创建 10 个测试。如果你想尝试做更多的比较，可再编写一些测试，并将它们加入到 conditional_tests.py 中。对于下面列出的各种测试，至少编写一个结果为 True 和 False 的测试。

  • 检查两个字符串相等和不等。
  • 使用函数 lower() 的测试。
  • 检查两个数字相等、不等、大于、小于、大于等于和小于等于。
  • 使用关键字 and 和 or 的测试。
  • 测试特定的值是否包含在列表中。
  • 测试特定的值是否未包含在列表中。
1
2
3
4
5
tset = ["'abc' == 'abc'", "'abcd' == 'abc'", "'Abc'.lower() == 'abc'", "'Abc'.lower() == 'Abc'", "5 == 5", "5 == 6", "5 != 6", "5 != 5", "5 > 5", "5 > 4", "5 < 5", "5 < 6", "5 >= 5", "5 >= 4", "5 <= 5", "5 <= 4", "True and True", "True and True", "False or False", "False or True", "1 in [1, 2]", "1 in [2, 3]", "1 not in [2, 3]", "1 not in [1, 2]"]
for i in tset:
    print(i)
    print(eval(i))
    print("\n")

5-3 外星人颜色 #1 ：假设在游戏中刚射杀了一个外星人，请创建一个名为 alien_color 的变量，并将其设置为 ‘green’ 、 ‘yellow’ 或 ‘red’ 。

  • 编写一条 if 语句，检查外星人是否是绿色的；如果是，就打印一条消息，指出玩家获得了 5 个点。
  • 编写这个程序的两个版本，在一个版本中上述测试通过了，而在另一个版本中未通过（未通过测试时没有输出）。
1
2
3
4
5
6
alien_color = 'green'
if alien_color == 'green':
    print("You get 5 points.")
alien_color = 'yellow'
if alien_color == 'green':
    print("You get 5 points.")

5-4 外星人颜色 #2 ：像练习 5-3 那样设置外星人的颜色，并编写一个 if-else 结构。

  • 如果外星人是绿色的，就打印一条消息，指出玩家因射杀该外星人获得了 5 个点。
  • 如果外星人不是绿色的，就打印一条消息，指出玩家获得了 10 个点。
  • 编写这个程序的两个版本，在一个版本中执行 if 代码块，而在另一个版本中执行 else 代码块。
1
2
3
4
5
6
7
8
9
10
alien_color = 'green'
if alien_color == 'green':
    print("You get 5 points.")
else:
    print("You get 10 points.")
alien_color = 'yellow'
if alien_color == 'green':
    print("You get 5 points.")
else:
    print("You get 10 points.")

5-5 外星人颜色 #3 ：将练习 5-4 中的 if-else 结构改为 if-elif-else 结构。

  • 如果外星人是绿色的，就打印一条消息，指出玩家获得了 5 个点。
  • 如果外星人是黄色的，就打印一条消息，指出玩家获得了 10 个点。
  • 如果外星人是红色的，就打印一条消息，指出玩家获得了 15 个点。
  • 编写这个程序的三个版本，它们分别在外星人为绿色、黄色和红色时打印一条消息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
alien_color = 'green'
if alien_color == 'green':
    print("You get 5 points.")
elif alien_color == 'yellow':
    print("You get 10 points.")
else:
    print("You get 15 points.")
alien_color = 'yellow'
if alien_color == 'green':
    print("You get 5 points.")
elif alien_color == 'yellow':
    print("You get 10 points.")
else:
    print("You get 15 points.")
alien_color = 'red'
if alien_color == 'green':
    print("You get 5 points.")
elif alien_color == 'yellow':
    print("You get 10 points.")
else:
    print("You get 15 points.")

5-6 人生的不同阶段 ：设置变量 age 的值，再编写一个 if-elif-else 结构，根据 age 的值判断处于人生的哪个阶段。

  • 如果一个人的年龄小于 2 岁，就打印一条消息，指出他是婴儿。
  • 如果一个人的年龄为 2 （含）～ 4 岁，就打印一条消息，指出他正蹒跚学步。
  • 如果一个人的年龄为 4 （含）～ 13 岁，就打印一条消息，指出他是儿童。
  • 如果一个人的年龄为 13 （含）～ 20 岁，就打印一条消息，指出他是青少年。
  • 如果一个人的年龄为 20 （含）～ 65 岁，就打印一条消息，指出他是成年人。
  • 如果一个人的年龄超过 65 （含）岁，就打印一条消息，指出他是老年人。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def tage(age):
    if age < 2:
        print("他是婴儿")
    elif age < 4:
        print("他正蹒跚学步")
    elif age < 13:
        print("他是儿童")
    elif age < 20:
        print("他是青少年")
    elif age < 65:
        print("他是成年人")
    else:
        print("他是老年人")
tage(1)
tage(3)
tage(12)
tage(19)
tage(64)
tage(65)

5-7 喜欢的水果 ：创建一个列表，其中包含你喜欢的水果，再编写一系列独立的 if 语句，检查列表中是否包含特定的水果。

  • 将该列表命名为 favorite_fruits ，并在其中包含三种水果。
  • 编写 5 条 if 语句，每条都检查某种水果是否包含在列表中，如果包含在列表中，就打印一条消息，如 “You really like bananas!” 。
1
2
3
4
5
6
7
8
9
def tf(name):
    favorite_fruits = ["apple", "banana", "orange"]
    if name in favorite_fruits:
        print("You eally like %s!"%name)
tf("apple")
tf("banana")
tf("orange")
tf("pear")
tf("strawberry")

##5-8 以特殊方式跟管理员打招呼 ：创建一个至少包含 5 个用户名的列表，且其中一个用户名为 ‘admin’ 。想象你要编写代码，在每位用户登录网站后都打印一条问候消息。遍历用户名列表，并向每位用户打印一条问候消息。

  • 如果用户名为 ‘admin’ ，就打印一条特殊的问候消息，如 “Hello admin, would you like to see a status report?” 。
  • 否则，打印一条普通的问候消息，如 “Hello Eric, thank you for logging in again” 。
1
2
3
4
5
6
n = ["admin", "Eric", "Link", "Zelda", "Mifa"]
for i in n:
    if i == 'admin':
        print("Hello admin, would you like to see a status report?")
    else:
        print("Hello %s, thank you for logging in again."%i)

5-9 处理没有用户的情形 ：在为完成练习 5-8 编写的程序中，添加一条 if 语句，检查用户名列表是否为空。

  • 如果为空，就打印消息 “We need to find some users!” 。
  • 删除列表中的所有用户名，确定将打印正确的消息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
n = ["admin", "Eric", "Link", "Zelda", "Mifa"]
if len(n) == 0:
    print("We need to find some users!")
else:
	for i in n:
    	if i == 'admin':
        	print("Hello admin, would you like to see a status report?")
    	else:
        	print("Hello %s, thank you for logging in again."%i)
n = []
if len(n) == 0:
    print("We need to find some users!")
else:
	for i in n:
    	if i == 'admin':
        	print("Hello admin, would you like to see a status report?")
    	else:
        	print("Hello %s, thank you for logging in again."%i)

5-10 检查用户名 ：按下面的说明编写一个程序，模拟网站确保每位用户的用户名都独一无二的方式。

  • 创建一个至少包含 5 个用户名的列表，并将其命名为 current_users 。
  • 再创建一个包含 5 个用户名的列表，将其命名为 new_users ，并确保其中有一两个用户名也包含在列表 current_users 中。
  • 遍历列表 new_users ，对于其中的每个用户名，都检查它是否已被使用。如果是这样，就打印一条消息，指出需要输入别的用户名；否则，打印一条消息，指出这个用户名未被使用。
  • 确保比较时不区分大消息；换句话说，如果用户名 ‘John’ 已被使用，应拒绝用户名 ‘JOHN’ 。
1
2
3
4
5
6
7
current_users = ["admin", "Eric", "Link", "Zelda", "Mifa"]
new_users = ["Admin", "ErIc", "Mario", "Peach", "Komeji Koishi"]
for i in new_users:
    if i.lower() in [j.lower() for j in current_users]:
        print("Please enter another name.")
    else:
        print("This username is not used.")

5-11 序数 ：序数表示位置，如 1st 和 2nd 。大多数序数都以 th 结尾，只有 1 、 2 和 3 例外。

  • 在一个列表中存储数字 1~9 。
  • 遍历这个列表。
  • 在循环中使用一个 if-elif-else 结构，以打印每个数字对应的序数。输出内容应为 1st 、 2nd 、 3rd 、 4th 、 5th 、 6th 、 7th 、 8th 和 9th ，但每个序数都独占一行。
1
2
3
4
5
6
7
8
n = list(range(1, 10))
for i in n:
    if i == 1:
        print("1st")
    elif i == 2:
        print("2nd")
    else:
        print("%dth"%i)

##6-1 人 ：使用一个字典来存储一个熟人的信息，包括名、姓、年龄和居住的城市。该字典应包含键 first_name 、 last_name 、 age 和 city 。将存储在该字典中的每项信息都打印出来。

1
2
3
info = {"first_name": "Riku", "last_name": "Dora", "age": 18, "city": "Unkown"}
for key, value in info.items():
    print("%s\t: %s"%(key, value))

##6-2 喜欢的数字 ：使用一个字典来存储一些人喜欢的数字。请想出 5 个人的名字，并将这些名字用作字典中的键；想出每个人喜欢的一个数字，并将这些数字作为值存储在字典中。打印每个人的名字和喜欢的数字。为让这个程序更有趣，通过询问朋友确保数据是真实的。

1
2
3
num = {"Link": 1, "Zelda": 2, "Mifa": 3, "Mario": 4, "Peach": 5}
for key, value in num.items():
    print("%s likes %s."%(key, value))

6-3 词汇表 ： Python 字典可用于模拟现实生活中的字典，但为避免混淆，我们将后者称为词汇表。

  • 想出你在前面学过的 5 个编程词汇，将它们用作词汇表中的键，并将它们的含义作为值存储在词汇表中。
  • 以整洁的方式打印每个词汇及其含义。为此，你可以先打印词汇，在它后面加上一个冒号，再打印词汇的含义；也可在一行打印词汇，再使用换行符（ \n ）插入一个空行，然后在下一行以缩进的方式打印词汇的含义。
1
2
3
d = {"integer": "integer", "double": "double precision float point number", "float": "single precision float point number", "function": "a procedure process data", "variable": "a place which can be read and write"}
for key, value in d.items():
    print("%s\t: %s"%(key, value))

##6-4 词汇表 2 ：既然你知道了如何遍历字典，现在请整理你为完成练习 6-3 而编写的代码，将其中的一系列 print 语句替换为一个遍历字典中的键和值的循环。确定该循环正确无误后，再在词汇表中添加 5 个 Python 术语。当你再次运行这个程序时，这些新术语及其含义将自动包含在输出中。

1
2
3
d = {"integer": "integer", "double": "double precision float point number", "float": "single precision float point number", "function": "a procedure process data", "variable": "a place which can be read and write", "bool": "bool", "char": "char", "short": "short integer", "long": "long integer", "long long": "long long integer"}
for key, value in d.items():
    print("%s\t: %s"%(key, value))

##6-5 河流 ：创建一个字典，在其中存储三条大河流及其流经的国家。其中一个键 — 值对可能是 ‘nile’: ‘egypt’ 。

  • 使用循环为每条河流打印一条消息，如 “The Nile runs through Egypt.” 。
  • 使用循环将该字典中每条河流的名字都打印出来。
  • 使用循环将该字典包含的每个国家的名字都打印出来。
1
2
3
4
5
r = {"Nile": "Egypt", "Huang": "China", "Chang": "China"}
for key, value in r.items():
    print("The %s runs through %s."%(key, value))
    print(key)
    print(value)

6-6 调查 ：在 6.3.1 节编写的程序 favorite_languages.py 中执行以下操作。

  • 创建一个应该会接受调查的人员名单，其中有些人已包含在字典中，而其他人未包含在字典中。
  • 遍历这个人员名单，对于已参与调查的人，打印一条消息表示感谢。对于还未参与调查的人，打印一条消息邀请他参与调查。
1
2
3
4
5
6
7
8
9
10
11
12
p = ['jen', 'sarah', 'edward', 'phil', 'link']
favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'ruby',
	'phil': 'python',
}
for name in p:
	if name in favorite_languages:
        print("%s, thank you to attend this survey!"%name)
    else:
        print("%s, I want to invite you to do a survey."%name)

##6-7 人 ：在为完成练习 6-1 而编写的程序中，再创建两个表示人的字典，然后将这三个字典都存储在一个名为 people 的列表中。遍历这个列表，将其中每个人的所有信息都打印出来。

1
2
3
4
5
6
7
8
l = [
    {"first_name": "Riku", "last_name": "Dora", "age": 18, "city": "Unkown"},
    {"first_name": "Shuvi", "last_name": "Dora", "age": 18, "city": "Unkown"},
    {"first_name": "Steven", "last_name": "Dora", "age": 18, "city": "Unkown"}
]
for info in l:
    for key, value in info.items():
    	print("%s\t: %s"%(key, value))

##6-8 宠物 ：创建多个字典，对于每个字典，都使用一个宠物的名称来给它命名；在每个字典中，包含宠物的类型及其主人的名字。将这些字典存储在一个名为 pets的列表中，再遍历该列表，并将宠物的所有信息都打印出来。

1
2
3
4
5
6
7
8
9
10
d = {
    "john" : {"type": "dog", "master": "link"},
    "johnson" : {"type": "dog", "master": "zelda"},
    "zoom" : {"type": "dog", "master": "mifa"}
}
for i, j in d.items():
    print("%s : {"%i)
    for k, l in j.items():
        print("\t%s : %s"%(k, l))
    print("}")

##6-9 喜欢的地方 ：创建一个名为 favorite_places 的字典。在这个字典中，将三个人的名字用作键；对于其中的每个人，都存储他喜欢的 1~3 个地方。为让这个练习更有趣些，可让一些朋友指出他们喜欢的几个地方。遍历这个字典，并将其中每个人的名字及其喜欢的地方打印出来。

1
2
3
4
5
6
7
8
9
10
favorite_places = {
    "link": ["p1", "p2", "p3"],
    "zelda": ["p4", "p5", "p6"],
    "mifa": ["p7", "p8", "p9"]
}
for i, j in favorite_places.items():
    print("%s : ["%i)
    for k in j:
        print("\t%s"%k)
    print("]")

##6-10 喜欢的数字 ：修改为完成练习 6-2 而编写的程序，让每个人都可以有多个喜欢的数字，然后将每个人的名字及其喜欢的数字打印出来。

1
2
3
4
5
6
7
8
9
10
11
12
num = {
    "Link": [1, 6],
    "Zelda": [2, 7],
    "Mifa": [3, 8],
    "Mario": [4, 9],
    "Peach": [5, 10]
}
for key, value in num.items():
    print("%s likes ["%key)
    for i in value:
        print("\t%d"%i)
    print("]")

##6-11 城市 ：创建一个名为 cities 的字典，其中将三个城市名用作键；对于每座城市，都创建一个字典，并在其中包含该城市所属的国家、人口约数以及一个有关该城市的事实。在表示每座城市的字典中，应包含 country 、 population 和 fact 等键。将每座城市的名字以及有关它们的信息都打印出来。

1
2
3
4
5
6
7
8
9
10
cities = {
    "name1": {"country": "country1", "population": "123456", "fact": "unkown"},
    "name2": {"country": "country2", "population": "234567", "fact": "unkown"},
    "name3": {"country": "country3", "population": "345678", "fact": "unkown"}
}
for i, j in cities.items():
    print("%s : {"%i)
    for k, l in j.items():
        print("\t%s : %s"%(k, l))
    print("}")

##6-12 扩展 ：本章的示例足够复杂，可以以很多方式进行扩展了。请对本章的一个示例进行扩展：添加键和值、调整程序要解决的问题或改进输出的格式。

1
2
3
4
5
6
7
8
9
10
11
favorite_languages = {
	'jen': ['python', 'ruby'],
	'sarah': ['c'],
	'edward': ['ruby', 'go'],
	'phil': ['python', 'haskell'],
    'link': ['java', 'asm']
}
for name, languages in favorite_languages.items():
	print("\n" + name.title() + "'s favorite languages are:")
for language in languages:
	print("\t" + language.title())

高级编程技术 作业2

3-1 姓名： 将一些朋友的姓名存储在一个列表中，并将其命名为 names 。依次访问该列表中的每个元素，从而将每个朋友的姓名都打印出来。

1
2
3
names = ["Link", "Zelda"]
for i in names:
    print(i)

## 3-2 问候语： 继续使用练习 3-1 中的列表，但不打印每个朋友的姓名，而为每人打印一条消息。每条消息都包含相同的问候语，但抬头为相应朋友的姓名。

1
2
3
names = ["Link", "Zelda"]
for i in names:
    print("Hello, "+i+'!')

## 3-3 自己的列表： 想想你喜欢的通勤方式，如骑摩托车或开汽车，并创建一个包含多种通勤方式的列表。根据该列表打印一系列有关这些通勤方式的宣言，如 “I would like to own a Honda motorcycle” 。

1
2
3
tools = ["Honda motorcycle", "Apachi helicopter", "F-22"]
for i in tools:
    print("I would like to own a " + i)

## 3-4 嘉宾名单 ：如果你可以邀请任何人一起共进晚餐（无论是在世的还是故去的），你会邀请哪些人？请创建一个列表，其中包含至少 3 个你想邀请的人；然后，使用这个列表打印消息，邀请这些人来与你共进晚餐。

1
2
3
4
5
6
7
names = ["Link", "Zelda", "Mifa"]
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)

## 3-5 修改嘉宾名单 ：你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。

  • 以完成练习 3-4 时编写的程序为基础，在程序末尾添加一条 print 语句，指出哪位嘉宾无法赴约。
  • 修改嘉宾名单，将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。
  • 再次打印一系列消息，向名单中的每位嘉宾发出邀请。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
names = ["Link", "Zelda", "Mifa"]
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)
absent = "Mifa"
print("However, " + absent + " can't have a dinner with us.")
for i in range(len(names)):
    if names[i] == absent:
        names[i] = "Zoda"
        break
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)

## 3-6 添加嘉宾 ：你刚找到了一个更大的餐桌，可容纳更多的嘉宾。请想想你还想邀请哪三位嘉宾。

  • 以完成练习 3-4 或练习 3-5 时编写的程序为基础，在程序末尾添加一条 print 语句，指出你找到了一个更大的餐桌。
  • 使用 insert() 将一位新嘉宾添加到名单开头。
  • 使用 insert() 将另一位新嘉宾添加到名单中间。
  • 使用 append() 将最后一位新嘉宾添加到名单末尾。
  • 打印一系列消息，向名单中的每位嘉宾发出邀请。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
names = ["Link", "Zelda", "Mifa"]
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)
print("I found a bigger table.")
names.insert(0, "Mario")
names.insert(2, "Pitch")
names.append("Satori")
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)

## 3-7 缩减名单 ：你刚得知新购买的餐桌无法及时送达，因此只能邀请两位嘉宾。

  • 以完成练习 3-6 时编写的程序为基础，在程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
  • 使用 pop() 不断地删除名单中的嘉宾，直到只有两位嘉宾为止。每次从名单中弹出一位嘉宾时，都打印一条消息，让该嘉宾知悉你很抱歉，无法邀请他来共进
    晚餐。
  • 对于余下的两位嘉宾中的每一位，都打印一条消息，指出他依然在受邀人之列。
  • 使用 del 将最后两位嘉宾从名单中删除，让名单变成空的。打印该名单，核实程序结束时名单确实是空的。
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
names = ["Link", "Zelda", "Mifa"]
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)
print("I found a bigger table.")
names.insert(0, "Mario")
names.insert(2, "Pitch")
names.append("Satori")
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)
print("I'm sorry that the table maybe unavailable, so I can only invite two people.")
while len(names) > 2:
    print(names.pop() + ", I'm sorry that I can't invite you to have a dinner.")
for i in names:
    print(i + ", I am so happy that I will have a dinner with you.")
del names[0]
del names[0]
print(names)

## 3-8 放眼世界 ：想出至少 5 个你渴望去旅游的地方。

  • 将这些地方存储在一个列表中，并确保其中的元素不是按字母顺序排列的。
  • 按原始排列顺序打印该列表。不要考虑输出是否整洁的问题，只管打印原始 Python 列表。
  • 使用 sorted() 按字母顺序打印这个列表，同时不要修改它。
  • 再次打印该列表，核实排列顺序未变。
  • 使用 sorted() 按与字母顺序相反的顺序打印这个列表，同时不要修改它。
  • 再次打印该列表，核实排列顺序未变。
  • 使用 reverse() 修改列表元素的排列顺序。打印该列表，核实排列顺序确实变了。
  • 使用 reverse() 再次修改列表元素的排列顺序。打印该列表，核实已恢复到原来的排列顺序。
  • 使用 sort() 修改该列表，使其元素按字母顺序排列。打印该列表，核实排列顺序确实变了。
  • 使用 sort() 修改该列表，使其元素按与字母顺序相反的顺序排列。打印该列表，核实排列顺序确实变了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
p = ["Tokyo", "New York", "Stanford", "Akiba", "London"]
print(p)
print(sorted(p))
print(p)
print(sorted(p, reverse=True))
print(p)
p.reverse()
print(p)
p.reverse()
print(p)
p.sort()
print(p)
p.sort(reverse=True)
print(p)

## 3-9 晚餐嘉宾 ：在完成练习 3-4~ 练习 3-7 时编写的程序之一中，使用 len() 打印一条消息，指出你邀请了多少位嘉宾来与你共进晚餐。

1
2
3
4
5
6
7
8
names = ["Link", "Zelda", "Mifa"]
mes = "I want to invite"
for i in names:
    mes += " "
    mes += i
mes += " to have a dinner."
print(mes)
print("I have invited " + str(len(names)) + " people to my dinner.")

## 3-10 尝试使用各个函数 ：想想可存储到列表中的东西，如山岳、河流、国家、城市、语言或你喜欢的任何东西。编写一个程序，在其中创建一个包含这些元素的列表，然后，对于本章介绍的每个函数，都至少使用一次来处理这个列表。

1
# Ignore

## 3-11 有意引发错误 ：如果你还没有在程序中遇到过索引错误，就尝试引发一个这种错误。在你的一个程序中，修改其中的索引，以引发索引错误。关闭程序前，务必消除这个错误。

1
2
names = ["Link", "Zelda", "Mifa"]
names[666] = "Mario"

## 4-1 比萨 ：想出至少三种你喜欢的比萨，将其名称存储在一个列表中，再使用 for 循环将每种比萨的名称都打印出来。

  • 修改这个 for 循环，使其打印包含比萨名称的句子，而不仅仅是比萨的名称。对于每种比萨，都显示一行输出，如 “I like pepperoni pizza” 。
  • 在程序末尾添加一行代码，它不在 for 循环中，指出你有多喜欢比萨。输出应包含针对每种比萨的消息，还有一个总结性句子，如 “I really love pizza!” 。
1
2
3
4
5
6
p = ["AAA", "BBB", "CCC"]
for i in p:
    print(i)
for i in p:
    print("I like " + i + " pizza!")
print("I really love pizza!")

## 4-2 动物 ：想出至少三种有共同特征的动物，将这些动物的名称存储在一个列表中，再使用 for 循环将每种动物的名称都打印出来。

  • 修改这个程序，使其针对每种动物都打印一个句子，如 “A dog would make a great pet” 。
  • 在程序末尾添加一行代码，指出这些动物的共同之处，如打印诸如 “Any of these animals would make a great pet!” 这样的句子。
1
2
3
4
p = ["dog", "cat", "bird"]
for i in p:
    print("A " + i + " would make a great pet.")
print("Any of these animals would make a great pet!")

## 4-3 数到 20 ：使用一个 for 循环打印数字 1~20 （含）。

1
2
for i in range(1, 21):
    print(i)

## 4-4 一百万 ：创建一个列表，其中包含数字 1~1 000 000 ，再使用一个 for 循环将这些数字打印出来（如果输出的时间太长，按 Ctrl + C 停止输出，或关闭输出窗口）。

1
2
3
4
5
l = []
for i in range(1, 1000001):
    l.append(i)
for i in l:
    print(i)

## 4-5 计算 1~1 000 000 的总和 ：创建一个列表，其中包含数字 1~1 000 000 ，再使用 min() 和 max() 核实该列表确实是从 1 开始，到 1 000 000 结束的。另外，对这个列表调用函数 sum() ，看看 Python 将一百万个数字相加需要多长时间。

1
2
3
4
5
6
l = []
for i in range(1, 1000001):
    l.append(i)
print(min(l))
print(max(l))
print(sum(l))

## 4-6 奇数 ：通过给函数 range() 指定第三个参数来创建一个列表，其中包含 1~20 的奇数；再使用一个 for 循环将这些数字都打印出来。

1
2
3
4
5
l = []
for i in range(1, 21, 2):
    l.append(i)
for i in l:
    print(i)

## 4-7 3 的倍数 ：创建一个列表，其中包含 3~30 内能被 3 整除的数字；再使用一个 for 循环将这个列表中的数字都打印出来。

1
2
3
4
5
l = []
for i in range(3, 31, 3):
    l.append(i)
for i in l:
    print(i)

## 4-8 立方 ：将同一个数字乘三次称为立方。例如，在 Python 中， 2 的立方用 2**3 表示。请创建一个列表，其中包含前 10 个整数（即 1~10 ）的立方，再使用一个 for 循环将这些立方数都打印出来。

1
2
3
4
5
l = []
for i in range(1, 11):
    l.append(i**3)
for i in l:
    print(i)

## 4-9 立方解析 ：使用列表解析生成一个列表，其中包含前 10 个整数的立方。

1
2
l = [i**3 for i in range(1, 11)]
print(l)

## 4-10 切片 ：选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。

  • 打印消息 “The first three items in the list are:” ，再使用切片来打印列表的前三个元素。
  • 打印消息 “Three items from the middle of the list are:” ，再使用切片来打印列表中间的三个元素。
  • 打印消息 “The last three items in the list are:” ，再使用切片来打印列表末尾的三个元素。
1
2
3
4
5
6
7
l = list(range(1, 11))
print("The first three items in the list are:")
print(l[0:3])
print("Three items from the middle of the list are:")
print(l[len(l)//2-1:len(l)//2+2])
print("The last three items in the list are:")
print(l[-3:-1])

## 4-11 你的比萨和我的比萨 ：在你为完成练习 4-1 而编写的程序中，创建比萨列表的副本，并将其存储到变量 friend_pizzas 中，再完成如下任务。

  • 在原来的比萨列表中添加一种比萨。
  • 在列表 friend_pizzas 中添加另一种比萨。
  • 核实你有两个不同的列表。为此，打印消息 “My favorite pizzas are:” ，再使用一个 for 循环来打印第一个列表；打印消息 “My friend’s favorite pizzas are:” ，再使用一个 for 循环来打印第二个列表。核实新增的比萨被添加到了正确的列表中。
1
2
3
4
5
6
7
8
9
p = ["AAA", "BBB", "CCC"]
friend_pizzas = p[:]
friend_pizzas.append("DDD")
print("My favorite pizzas are:")
for i in p:
    print(i)
print("My friend's favorite pizzas are:")
for i in friend_pizzas:
    print(i)

## 4-12 使用多个循环 ：在本节中，为节省篇幅，程序 foods.py 的每个版本都没有使用 for 循环来打印列表。请选择一个版本的 foods.py ，在其中编写两个 for 循环，将各个食品列表都打印出来。

1
2
3
4
5
6
7
8
9
10
my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
for i in my_foods:
    print(i)
print("\nMy friend's favorite foods are:")
for i in friend_pizzas:
    print(i)

## 4-13 自助餐 ：有一家自助式餐馆，只提供五种简单的食品。请想出五种简单的食品，并将其存储在一个元组中。

  • 使用一个 for 循环将该餐馆提供的五种食品都打印出来。
  • 尝试修改其中的一个元素，核实 Python 确实会拒绝你这样做。
  • 餐馆调整了菜单，替换了它提供的其中两种食品。请编写一个这样的代码块：给元组变量赋值，并使用一个 for 循环将新元组的每个元素都打印出来。
1
2
3
4
5
f = ("a", "b", "c", "d", "e")
f[0] = "f"
f = ("g", "h", "c", "d", "e")
for i in f:
    print(i)

高级编程技术 作业1

1. 浏览Python主页（https://www.python.org/），在博客上写下你有哪些发现和收获

python官网还是万年不变，会议活动也一如既往地举行。

#2. 假设你已经成为一名Python编程高手，你打算实现怎样的程序？在博客上写下你的目标

到时候还是用来写一堆脚本来进行自动化操作吧，再加上一些小工具，粘合剂等（笑）。

#3. 教材中课后的练习，2-1到2-11，选一些写到你的博客上

2-1 简单消息：将一条消息存储到变量中，再将其打印出来。

1
2
message = "Hello, World!"
print(message)

2-2 多条简单消息： 将一条消息存储到变量中，将其打印出来；再将变量的值修改为一条新消息，并将其打印出来。

1
2
3
4
message = "Hello, World!"
print(message)
message = "Goodbye, World!"
print(message)

2-3 个性化消息： 将用户的姓名存到一个变量中，并向该用户显示一条消息。显示的消息应非常简单，如 “Hello Eric, would you like to learn some Python today?” 。

1
2
name = "Link"
print("Hello " + name + ", would you like to learn some Python today?")

2-4 调整名字的大小写： 将一个人名存储到一个变量中，再以小写、大写和首字母大写的方式显示这个人名。

1
2
3
4
name = "zELDA"
print(name.lower())
print(name.upper())
print(name.title())

##2-5 名言： 找一句你钦佩的名人说的名言，将这个名人的姓名和他的名言打印出来。输出应类似于下面这样（包括引号）：

1
2
say = 'Albert Einstein once said, "A person who never made a mistake never tried anything new."'
print(say)

##2-6 名言 2 ： 重复练习 2-5 ，但将名人的姓名存储在变量 famous_person 中，再创建要显示的消息，并将其存储在变量 message 中，然后打印这条消息。

1
2
3
famous_person = "Albert Einstein"
message = "A person who never made a mistake never tried anything new."
print(famous_person + ' once said, "' + message + '"')

##2-7 剔除人名中的空白： 存储一个人名，并在其开头和末尾都包含一些空白字符。务必至少使用字符组合 “\t” 和 “\n” 各一次。打印这个人名，以显示其开头和末尾的空白。然后，分别使用剔除函数 lstrip() 、 rstrip() 和 strip() 对人名进行处理，并将结果打印出来。

1
2
3
4
5
name = "\t\nAlbert Einstein\t\n"
print(name)
print(name.lstrip())
print(name.rstrip())
print(name.strip())

##2-8 数字 8 ： 编写 4 个表达式，它们分别使用加法、减法、乘法和除法运算，但结果都是数字 8 。为使用 print 语句来显示结果，务必将这些表达式用括号括起来，也就是说，你应该编写 4 行类似于下面的代码：

1
2
3
4
print(1 + 7)
print(9 - 1)
print(2 * 4)
print(16 / 2)

2-9 最喜欢的数字： 将你最喜欢的数字存储在一个变量中，再使用这个变量创建一条消息，指出你最喜欢的数字，然后将这条消息打印出来。

1
2
3
num = 6
message = "My favourite number is " + str(num) + "."
print(message)

2-10 添加注释： 选择你编写的两个程序，在每个程序中都至少添加一条注释。如果程序太简单，实在没有什么需要说明的，就在程序文件开头加上你的姓名和当前日期，再用一句话阐述程序的功能。

1
2
3
4
5
# @author: secret
# @date: 2018/03/09
# @description: Print "Hello, World!" on the screen.
message = "Hello, World!"
print(message)

2-11 Python 之禅： 在 Python 终端会话中执行命令 import this ，并粗略地浏览一下其他的指导原则。

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
Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!