前文
接着上一篇文章，练习题目是到了字典了哈 。
接着来开始！????????????????????????
1.用户输入和while 循环
# 7-1 汽车租赁 ： 编写一个程序， 询问用户要租赁什么样的汽车， 并打印一条消息， 如“Let me see if I can find you a Subaru”。
msg = input('请输入您要租赁的汽车名称：')
print('Let me see if I can find you a ' + msg)
# 7-2 餐馆订位 ： 编写一个程序， 询问用户有多少人用餐。 如果超过8人， 就打印一条消息， 指出没有空桌； 否则指出有空桌。
msg = input ('请输入用餐人数：')
if int(msg) > 8:
print('没有空桌')
else :
print('有空桌')
# 7-3 10的整数倍 ： 让用户输入一个数字， 并指出这个数字是否是10的整数倍。
msg = input('请输入一个数字，将自动计算是否为10的整数倍：')
if int(msg) % 10 == 0 :
print(msg + '是 10 的整数倍')
else:
print(msg + '不是 10 的整数倍')
# 7-4 比萨配料 ： 编写一个循环， 提示用户输入一系列的比萨配料， 并在用户输入'quit' 时结束循环。 每当用户输入一种配料后，
# 都打印一条消息， 说我们会在比萨中添加这种配料。
msg1 = ('请输入一种披萨配料，输入‘quit’后会退出程序，请输入：')
while True:
msg = input(msg1)
if 'quit' in msg:
break
else:
print('我们会在比萨中添加这种配料: ' + msg)
#这个input必须写在循环里，不然会一直输出
# 7-5 电影票 ： 有家电影院根据观众的年龄收取不同的票价： 不到3岁的观众免费； 3~12岁的观众为10美元； 超过12岁的观众为15美元。
# 请编写一个循环， 在其中询问用户的年龄， 并指出其票价。
msg = '请输入你的年龄：'
while True:
msg1 = input(msg)
if 'quit' in msg1:
print('已退出')
break
elif int(msg1) <3:
print('免费')
elif 3 <= int(msg1) <12:
print('\$10')
elif int(msg1) >= 12:
print('\$15')
# 7-6 三个出口 ： 以另一种方式完成练习7-4或练习7-5， 在程序中采取如下所有做法。
# 在while 循环中使用条件测试来结束循环。
# 使用变量active 来控制循环结束的时机。
# 使用break 语句在用户输入'quit' 时退出循环。
#7-6（1）
msg1 = ('请输入一种披萨配料，输入‘quit’后会退出程序，请输入：')
active1 = True
while active1:
msg = input(msg1)
if 'quit' in msg:
active1 = False
else:
print('我们会在比萨中添加这种配料: ' + msg)
#7-6（2）
ac = True
msg = '请输入你的年龄：'
while ac:
msg1 = input(msg)
if 'quit' in msg1:
print('已退出')
break
elif int(msg1) <3:
print('免费')
elif 3 <= int(msg1) <12:
print('\$10')
elif int(msg1) >= 12:
print('\$15')
# 7-7 无限循环 ： 编写一个没完没了的循环， 并运行它（要结束该循环， 可按Ctrl +C， 也可关闭显示输出的窗口） 。
while 1:
print('1')
# 7-8 熟食店 ： 创建一个名为sandwich_orders 的列表， 在其中包含各种三明治的名字； 再创建一个名为finished_sandwiches 的空列表。
# 遍历列表sandwich_orders ， 对于其中的每种三明治， 都打印一条消息， 如I made your tuna sandwich ，
# 并将其移到列表finished_sandwiches 。 所有三明治都制作好后， 打印一条消息， 将这些三明治列出来。
sandwich_orders = ['s1','s2','s3','s4']
finished_sandwiches = []
act = True
while act:
if int(len(sandwich_orders)) != 0:
cu_sw = sandwich_orders.pop()
finished_sandwiches.insert(0,cu_sw)
else:
act = False
print(finished_sandwiches)
# 7-9 五香烟熏牛肉（pastrami） 卖完了 ： 使用为完成练习7-8而创建的列表sandwich_orders ，
# 并确保'pastrami' 在其中至少出现了三次。 在程序开头附近添加这样的代码： 打印一条消息， 指出熟食店的五香烟熏牛肉卖完了；
# 再使用一个while 循环将列表sandwich_orders 中的'pastrami' 都删除。 确认最终的列表finished_sandwiches 中不包含'pastrami' 。
print('熟食店的五香烟熏牛肉卖完了')
sandwich_orders = ['s1','pastram','s2','pastram','s3','pastram','s4']
print(sandwich_orders)
while 'pastram' in sandwich_orders:
sandwich_orders.remove('pastram')
print(sandwich_orders)
# 7-10 梦想的度假胜地 ： 编写一个程序， 调查用户梦想的度假胜地。
# 使用类似于“If you could visit one place in the world, where would you go?”的提示， 并编写一个打印调查结果的代码块.
names = '请输入你的姓名：'
places = '请输入你想去的地点：'
dics = {}
ac = True
while ac:
name = input(names)
place = input(places)
dics[name] = place
repeat = input('还有其他人回答吗？（yes/no）')
if repeat == 'no':
ac = False
print(dics)
2.函数
# 8-1 消息 ： 编写一个名为display_message() 的函数， 它打印一个句子， 指出你在本章学的是什么。
# 调用这个函数， 确认显示的消息正确无误。
def display_message():
print('本章学习内容：def(函数)')
display_message()
# 8-2 喜欢的图书 ： 编写一个名为favorite_book() 的函数， 其中包含一个名为title 的形参。 这个函数打印一条消息，
# 如One of my favorite books isAlice in Wonderland 。 调用这个函数， 并将一本图书的名称作为实参传递给它。
def favorite_book(title,price):
print('One of my favorite books is： ' + title)
favorite_book('java程序设计','')
# 8-3 T恤 ： 编写一个名为make_shirt() 的函数， 它接受一个尺码以及要印到T恤上的字样。
# 这个函数应打印一个句子， 概要地说明T恤的尺码和字样。
# 使用位置实参调用这个函数来制作一件T恤； 再使用关键字实参来调用这个函数。
def make_shirt(size,msg):
if msg == '':
print('这件t恤衫的尺寸是：' + size + '； 印花文字为：' + '空')
else:
print('这件t恤衫的尺寸是：' + size + '；印花文字为：' + msg)
make_shirt('XXXL','')
make_shirt('XXXL',msg = 'hello_world!')
# 8-4 大号T恤 ： 修改函数make_shirt() ， 使其在默认情况下制作一件印有字样“I love Python”的大号T恤。
# 调用这个函数来制作如下T恤： 一件印有默认字样的大号T恤、
# 一件印有默认字样的中号T恤和一件印有其他字样的T恤（尺码无关紧要） 。
def make_shirt(size,msg = 'I love Python'):
print('这件t恤衫的尺寸是：' + size + '；印花文字为：' + msg)
make_shirt('大号T恤')
make_shirt('中号T恤')
make_shirt('小号T恤','其他字样')
# 8-5 城市 ： 编写一个名为describe_city() 的函数， 它接受一座城市的名字以及该城市所属的国家。
# 这个函数应打印一个简单的句子， 如Reykjavik is in Iceland 。 给用于存储国家的形参指定默认值。
# 为三座不同的城市调用这个函数， 且其中至少有一座城市不属于默认国家。
def describe_city(city_name,city_belong_country = 'china'):
print(city_name + ' is in ' + city_belong_country)
describe_city('shanghai')
describe_city('beijing')
describe_city('DC','america')
# 8-6 城市名 ： 编写一个名为city_country() 的函数， 它接受城市的名称及其所属的国家。
# 这个函数应返回一个格式类似于下面这样的字符串："Santiago, Chile"
# 至少使用三个城市-国家对调用这个函数， 并打印它返回的值。
def city_country(city_name,city_belong_country):
city_country1 = city_name + ',' +city_belong_country
return city_country1
a = city_country('shanghai','china')
b = city_country('beijing','china')
c = city_country('DC','America')
print(a)
print(b)
print(c)
# 8-7 专辑 ： 编写一个名为make_album() 的函数， 它创建一个描述音乐专辑的字典。
# 这个函数应接受歌手的名字和专辑名， 并返回一个包含这两项信息的字典。 使用这个函数创建三个表示不同专辑的字典，
# 并打印每个返回的值， 以核实字典正确地存储了专辑的信息。给函数make_album() 添加一个可选形参，
# 以便能够存储专辑包含的歌曲数。 如果调用这个函数时指定了歌曲数， 就将这个值添加到表示专辑的字典中。 调用这个
# 函数， 并至少在一次调用中指定专辑包含的歌曲数。
def make_album(singer_name,album_name,song_number = ''):
if song_number:
s_a = {'singer_name':singer_name,'album_name':album_name,'song_number' : song_number}
else:
s_a = {'singer_name':singer_name,'album_name':album_name}
return s_a
a = make_album('HanHong','QingZangGaoYuan','5')
b = make_album('AndiLiu','WangQingShui')
c = make_album('LiuHuan','YouAndMe','7')
print(a)
print(b)
print(c)
# 8-8 用户的专辑 ： 在为完成练习8-7编写的程序中， 编写一个while 循环， 让用户输入一个专辑的歌手和名称。
# 获取这些信息后， 使用它们来调用函数make_album() ， 并将创建的字典打印出来。 在这个while 循环中， 务必要提供退出途径。
def make_album(singer_name,album_name,song_number = ''):
if song_number:
s_a = {'singer_name':singer_name,'album_name':album_name,'song_number' : song_number}
else:
s_a = {'singer_name':singer_name,'album_name':album_name}
return s_a
s_n_inp = '请输入歌手名：（输入’quit‘后退出）'
a_n_inp = '请输入专辑名：（输入’quit‘后退出）'
ac = True
while ac:
a = input(s_n_inp)
b = input(a_n_inp)
if a == 'quit' or b == 'quit' :
break
else:
c = make_album(a,b)
print(c)
# 8-9 魔术师 ： 创建一个包含魔术师名字的列表， 并将其传递给一个名为show_magicians() 的函数， 这个函数打印列表中每个魔术师的名字。
name_list = ['mag1','mag2','mag3']
def show_magicians():
for name in name_list:
print(name)
show_magicians()
# 8-10 了不起的魔术师 ： 在你为完成练习8-9而编写的程序中， 编写一个名为make_great() 的函数，
# 对魔术师列表进行修改， 在每个魔术师的名字中都加入字样“theGreat”。 调用函数show_magicians() ， 确认魔术师列表确实变了。
name_list = ['mag1','mag2','mag3']
name_change = []
def make_great(name_list,name_change):
while name_list:
cur = name_list.pop()
cur = 'great' + cur
name_change.append(cur)
def show_magicians(name_change):
for name in name_change:
print(name)
make_great(name_list,name_change)
show_magicians(name_change)
# 8-11 不变的魔术师 ： 修改你为完成练习8-10而编写的程序， 在调用函数make_great() 时， 向它传递魔术师列表的副本。
# 由于不想修改原始列表， 请返回修改后的列表， 并将其存储到另一个列表中。 分别使用这两个列表来调用show_magicians() ，
# 确认一个列表包含的是原来的魔术师名字， 而另一个列表包含的是添加了字样“the Great”的魔术师名字。
name_list = ['mag1','mag2','mag3']
name_change = []
def make_great(name_list,name_change):
while name_list:
cur = name_list.pop()
cur = 'great' + cur
name_change.append(cur)
def show_magicians(name_change)
for name in name_change:
print(name)
make_great(name_list[:],name_change)
show_magicians(name_list)
show_magicians(name_change)
# 8-12 三明治 ： 编写一个函数， 它接受顾客要在三明治中添加的一系列食材。 这个函数只有一个形参（它收集函数调用中提供的所有食材） ，
# 并打印一条消息， 对顾客点的三明治进行概述。 调用这个函数三次， 每次都提供不同数量的实参。
def sand_make(*ingredients):
print( '添加的食材有：')
for i in ingredients:
print('--' + i)
sand_make('1','2','3','4')
sand_make('0')
sand_make('1','2')
# 8-13 用户简介 ： 复制前面的程序user_profile.py， 在其中调用build_profile() 来创建有关你的简介；
# 调用这个函数时， 指定你的名和姓， 以及三个描述你的键-值对。
def user_profile(first,last,**else_info):
name_file = {}
name_file['first_name'] = first
name_file['last_name'] = last
for k ,v in else_info.items():
name_file[k] = v
return name_file
user_a = user_profile('ma','yun',company = 'TaoBao',Sex = 'man')
print(user_a)
user_b = user_profile('1','2',Sex = 'man')
print(user_b)
# 8-14 汽车 ： 编写一个函数， 将一辆汽车的信息存储在一个字典中。 这个函数总是接受制造商和型号， 还接受任意数量的关键字实参。
# 这样调用这个函数： 提供必不可少的信息， 以及两个名称—值对， 如颜色和选装配件。 这个函数必须能够像下面这样进行调用：
# car = make_car('subaru', 'outback', color='blue', tow_package=True)
# 打印返回的字典， 确认正确地处理了所有的信息。
def car_msg(manufacturer,model,**else_info):
bas_msg = {}
bas_msg['manufacturer'] = manufacturer
bas_msg['model'] = model
for k ,v in else_info.items():
bas_msg[k] = v
return bas_msg
car = car_msg('subaru', 'outback', color='blue', tow_package=True)
print(car)
3.类
# 9-1 餐馆 ： 创建一个名为Restaurant 的类， 其方法__init__() 设置两个属性： restaurant_name 和cuisine_type 。 创建一个名
# 为describe_restaurant() 的方法和一个名为open_restaurant() 的方法， 其中前者打印前述两项信息， 而后者打印一条消息， 指出餐馆正在营业。
# 根据这个类创建一个名为restaurant 的实例， 分别打印其两个属性， 再调用前述两个方法。
class Restaurant():
def __init__(self,restaurant_name,cuisine_type):
"""初始化属性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 open')
restaurant = Restaurant('A','B')
print(restaurant.restaurant_name,'',restaurant.cuisine_type)
restaurant.describe_restaurant()
restaurant.open_restaurant()
# 9-2 三家餐馆 ： 根据你为完成练习9-1而编写的类创建三个实例， 并对每个实例调用方法describe_restaurant() 。
class Restaurant():
def __init__(self,restaurant_name,cuisine_type):
"""初始化属性name和age"""
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 open')
restaurant1 = Restaurant('A1','B1')
restaurant1.describe_restaurant()
restaurant2 = Restaurant('A2','B2')
restaurant2.describe_restaurant()
restaurant3 = Restaurant('A3','B3')
restaurant3.describe_restaurant()
# 9-3 用户 ： 创建一个名为User 的类， 其中包含属性first_name 和last_name ， 还有用户简介通常会存储的其他几个属性。 在类User 中定义一个名
# 为describe_user() 的方法， 它打印用户信息摘要； 再定义一个名为greet_user() 的方法， 它向用户发出个性化的问候。
# 创建多个表示不同用户的实例， 并对每个实例都调用上述两个方法
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 + self.last_name)
def greet_user(self):
print('你好！ ' + self.first_name + self.last_name)
user_a = User('Ma','Yun')
user_b = User('cheng','Long')
user_c = User('Li','LianJie')
user_a.describe_user()
user_b.describe_user()
user_c.describe_user()
user_a.greet_user()
user_b.greet_user()
user_c.greet_user()
# 9-4 就餐人数 ： 在为完成练习9-1而编写的程序中， 添加一个名为number_served 的属性， 并将其默认值设置为0。
# 根据这个类创建一个名为restaurant 的实例； 打印有多少人在这家餐馆就餐过， 然后修改这个值并再次打印它。
# 添加一个名为set_number_served() 的方法， 它让你能够设置就餐人数。 调用这个方法并向它传递一个值， 然后再次打印这个值。
# 添加一个名为increment_number_served() 的方法， 它让你能够将就餐人数递增。 调用这个方法并向它传递一个这样的值：
# 你认为这家餐馆每天可能接待的就餐人数。
class Restaurant():
def __init__(self,restaurant_name,cuisine_type):
self.restaurant_name = restaurant_name
self.cuisine_type = cuisine_type
self.number_served = 1
def describe_restaurant(self):
print(self.restaurant_name)
print(self.cuisine_type)
def open_restaurant(self):
print('Restaurant is open')
def number_served_info(self):
print('[' + self.restaurant_name + '] 这家餐馆每天可能接待的就餐人数: ' + str(self.number_served))
print('来 [' + self.restaurant_name + '] 吃 [' + self.cuisine_type + '] 的人有：'+str(self.number_served)+' 人！')
def set_number_served(self,number_info):
self.number_served = number_info
def increment_number_served(self,name_add):
self.number_served += name_add
restaurant = Restaurant('紫光阁','北京菜')
restaurant.number_served = 30
restaurant.set_number_served(1)
restaurant.increment_number_served(100)
restaurant.increment_number_served(100)
restaurant.increment_number_served(100)
restaurant.increment_number_served(100)
restaurant.number_served_info()
# 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。
class User():
def __init__(self, first_name, last_name):
'''主方法，内涵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 + self.last_name)
# print('共登录用户量：' + str(self.login_attempts))
print('共登录用户量：(重置中……)'+str(self.login_attempts))
def greet_user(self):
'''打印问候'''
print('你好！ ' + self.first_name + self.last_name)
def increment_login_attempts(self,number):
self.login_attempts += number
print('共登录用户量：' + str(self.login_attempts))
def reset_login_attempts(self):
self.login_attempts = 0
user_a = User('Ma','Yun')
user_a.increment_login_attempts(1)
user_a.increment_login_attempts(1)
user_a.increment_login_attempts(1)
user_a.reset_login_attempts()
user_a.describe_user()
# 9-6 冰淇淋小店 ： 冰淇淋小店是一种特殊的餐馆。 编写一个名为IceCreamStand 的类， 让它继承你为完成练习9-1或练习9-4
# 而编写的Restaurant 类。 这两个版本的Restaurant 类都可以， 挑选你更喜欢的那个即可。 添加一个名为flavors 的属性，
# 用于存储一个由各种口味的冰淇淋组成的列表。 编写一个显示这些冰淇淋的方法。 创建一个IceCreamStand 实例， 并调用这个方法。
class Restaurant():
def __init__(self,restaurant_name,cuisine_type):
"""初始化属性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 open')
class IceCreamStand(Restaurant):
def __init__(self,restaurant_name,cuisine_type):
super().__init__(restaurant_name,cuisine_type)
self.favorite = ['orange','apple']
def show_ice(self):
for i in self.favorite:
print(i)
IceCreamStand1 = IceCreamStand('beijingfandian','beijingcai')
IceCreamStand1.show_ice()
# 9-7 管理员 ： 管理员是一种特殊的用户。 编写一个名为Admin 的类， 让它继承你为完成练习9-3或练习9-5而编写的User 类。
# 添加一个名为privileges 的属性， 用于存储一个由字符串（如"can add post" 、 "can delete post" 、 "can ban user" 等）
# 组成的列表。 编写一个名为show_privileges() 的方法， 它显示管理员的权限。 创建一个Admin 实例， 并调用这个方法。
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 + self.last_name)
def greet_user(self):
print('你好！ ' + 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 del post','can ban user']
def show_privileges(self):
# print(self.privileges)
for i in self.privileges:
print("管理员权限有：" + i)
Admin1 = Admin('Ma','Yun')
Admin1.show_privileges()
# 9-8 权限 ： 编写一个名为Privileges 的类， 它只有一个属性——privileges ， 其中存储了练习9-7 所说的字符串列表。
# 将方法show_privileges() 移到这个类中。 在Admin 类中， 将一个Privileges 实例用作其属性。
# 创建一个Admin 实例， 并使用方法show_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 + self.last_name)
def greet_user(self):
print('你好！ ' + self.first_name + self.last_name)
class Admin(User):
def __init__(self,first_name,last_name):
super().__init__(first_name,last_name)
self.b = Privileges()
# self.privileges = ['can add post','can del post','can ban user']
# def show_privileges(self):
# # print(self.privileges)
# for i in self.privileges:
# print("管理员权限有：" + i)
class Privileges():
def __init__(self):
self.privileges = ['can add post','can del post','can ban user']
def show_privileges(self):
for i in self.privileges:
print("管理员权限有：" + i)
Admin1 = Admin('Ma','Yun')
Admin1.b.show_privileges()
# 9-9 电瓶升级 ： 在本节最后一个electric_car.py版本中， 给Battery 类添加一个名为upgrade_battery() 的方法。
# 这个方法检查电瓶容量， 如果它不是85， 就将它设置为85。 创建一辆电瓶容量为默认值的电动汽车， 调用方法get_range() ，
# 然后对电瓶进行升级， 并再次调用get_range() 。 你会看到这辆汽车的续航里程增加了。
class Car():
"""docstring for 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
# 打印里程消息
def read_odometer(self):
print("This car has " + str(self.odometer_reading) + " miles on it.")
# 更新里程数
def update_odometer(self, milegeage):
if milegeage >= self.odometer_reading:
self.odometer_reading = milegeage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
self.odometer_reading += miles
class Battery():
"""docstring for 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 upgrade_battery(self):
if self.battery_size != 85:
self.battery_size = 85
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)
self.upgrade_battery()
class ElectricCar(Car):
"""docstring for ElectricCar"""
def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery_size = Battery()
def describe_battery(self):
self.battery_size.battery_size()
def get_range(self):
self.battery_size.get_range()
my_tesla = ElectricCar('tesla', 'model s', 2016)
my_tesla.get_range()
my_tesla.get_range()
# 9-10 导入Restaurant 类 ： 将最新的Restaurant 类存储在一个模块中。 在另一个文件中， 导入Restaurant 类， 创建一个Restaurant 实例， 并调
# 用Restaurant 的一个方法， 以确认import 语句正确无误。
# restaurant.py
class Restraurant():
"""docstring for Restraurant"""
def __init__(self, restaurant_name, cuisine_type):
self.restaurant_name = restaurant_name
self.cuisine_type = cuisine_type
self.number_served = 0
def describe_restaurant(self):
print(self.restaurant_name, ":", self.cuisine_type)
def open_restaurant(self):
print("Is opening")
def set_number_served(self, number):
self.number_served = number
def get_number_served(self):
return self.number_served
def increment_number_served(self, number):
while self.number_served < number:
print(self.number_served)
self.number_served += 1
# coding.py
from restraurant import Restraurant
restraurant1 = Restraurant('A', 'B')
print(restraurant1.restaurant_name, " ", restraurant1.cuisine_type)
restraurant1.describe_restaurant()
restraurant1.open_restaurant()
print(restraurant1.get_number_served())
restraurant1.set_number_served(2)
print(restraurant1.get_number_served())
restraurant1.increment_number_served(10)
# 9-11 导入Admin 类 ： 以为完成练习9-8而做的工作为基础， 将User 、 Privileges 和Admin 类存储在一个模块中， 再创建一个文件， 在其中创建一个Admin 实例
# 并对其调用方法show_privileges() ， 以确认一切都能正确地运行。
# user.py
class User():
"""docstring for User"""
def __init__(self, first_name, last_name):
self.first_name = first_name
self.last_name = last_name
self.login_attempts = 0
def describe_name(self):
print("fitst_name :", self.first_name, " last_name: ", 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
class Privileges():
"""docstring for Privileges"""
def __init__(self):
self.privileges = ['can add post', 'can ban user', 'can delete post']
def show_privileges(self):
print(self.privileges)
class Admin(User):
"""docstring for Admin"""
def __init__(self, first_name, last_name):
super().__init__(first_name, last_name)
self.privileges = Privileges()
def show_privileges(self):
self.privileges.show_privileges()
# coding.py
from user import Admin
admin = Admin("Alice", 'Bob')
admin.show_privileges()
# 9-12 多个模块 ： 将User 类存储在一个模块中， 并将Privileges 和Admin 类存储在另一个模块中。 再创建一个文件， 在其中创建一个Admin 实例， 并对其调用方
# 法show_privileges() ， 以确认一切都依然能够正确地运行。
# privileges.py
class Privileges():
"""docstring for Privileges"""
def __init__(self):
self.privileges = ['can add post','can ban user','can delete post']
def show_privileges(self):
print(self.privileges)
# admin.py
class Admin(User):
"""docstring for Admin"""
def __init__(self, first_name, last_name):
super().__init__(first_name, last_name)
self.privileges = Privileges()
def show_privileges(self):
self.privileges.show_privileges()
# user.py
class User():
"""docstring for User"""
def __init__(self, first_name, last_name):
self.first_name = first_name
self.last_name = last_name
self.login_attempts = 0
def describe_name(self):
print("fitst_name :", self.first_name, " last_name: ", 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
# coding.py
from user import User
from admin import Admin
from privilege import Privilege
admin = Admin("Alice", 'Bob')
admin.show_privileges()
# 9-13 使用OrderedDict ： 在练习6-4中， 你使用了一个标准字典来表示词汇表。 请使用OrderedDict 类来重写这个程序，
# 并确认输出的顺序与你在字典中添加键—值对的顺序一致。
from collections import OrderedDict
favorite_languages = OrderedDict()
favorite_languages['ken'] = 'C'
favorite_languages['jack'] = 'PHP'
favorite_languages['ben'] = 'JAVA'
favorite_languages['phile'] = 'R'
for k,v in favorite_languages.items():
print(k+'___'+v)
# 9-14 骰子 ： 模块random 包含以各种方式生成随机数的函数， 其中的randint() 返回一个位于指定范围内的整数，
# 例如， 下面的代码返回一个1~6内的整数：
# from random import randint
# x = randint(1, 6)
# 请创建一个Die 类， 它包含一个名为sides 的属性， 该属性的默认值为6。 编写一个名为roll_die() 的方法，
# 它打印位于1和骰子面数之间的随机数。 创建一个6面的骰子， 再掷10次。 创建一个10面的骰子和一个20面的骰子， 并将它们都掷10次。
# 9-14 骰子 ： 模块random 包含以各种方式生成随机数的函数， 其中的randint() 返回一个位于指定范围内的整数，
# 例如， 下面的代码返回一个1~6内的整数：
# from random import randint
# x = randint(1, 6)
# 请创建一个Die 类， 它包含一个名为sides 的属性， 该属性的默认值为6。 编写一个名为roll_die() 的方法，
# 它打印位于1和骰子面数之间的随机数。 创建一个6面的骰子， 再掷10次。 创建一个10面的骰子和一个20面的骰子， 并将它们都掷10次。
from random import randint
class Die():
def __init__(self):
self.sides = 6
def roll_die(self):
x = randint(1,6)
self.sides = x
print(self.sides)
def roll_die10(self):
x = randint(1, 10)
self.sides = x
print(self.sides)
def roll_die20(self):
self.sides = randint(1, 20)
print(self.sides)
die = Die()
print("----------6 sides-------------")
for i in range(10):
die.roll_die()
print("----------10 sides-------------")
for i in range(10):
die.roll_die10()
print("----------20 sides-------------")
for i in range(10):
die.roll_die20()
# 9-15 Python Module of the Week ： 要了解Python标准库， 一个很不错的资源是网站Python Module of the Week。
# 请访问http://pymotw.com/ 并查看其中的目录， 在其中找一个你感兴趣的模块进行探索， 或阅读模块collections 和random 的文档
4.文件与异常
# 10-1 Python学习笔记 ： 在文本编辑器中新建一个文件， 写几句话来总结一下你至此学到的Python知识，
# 其中每一行都以“In Python you can”打头。 将这个文件命名为learning_python.txt，
# 并将其存储到为完成本章练习而编写的程序所在的目录中。 编写一个程序， 它读取这个文件， 并将你所写的内容打印三次：
# 第一次打印时读取整个文件； 第二次打印时遍历文件对象； 第三次打印时将各行存储在一个列表中， 再在with 代码块外打印它们。
f_name = 'msg/learning_python.txt'
with open(f_name) as f_name1:
print('_________"1"___________')
print(f_name1.read().rstrip())
with open(f_name) as f_name1:
print('_________"2"___________')
for i in f_name1:
print(i.rstrip())
with open(f_name) as f_name1:
print('_________"3"___________')
lines = f_name1.readlines()
for i in lines:
print(i.rstrip())
# 10-2 C语言学习笔记 ： 可使用方法replace() 将字符串中的特定单词都替换为另一个单词。 下面是一个简单的示例，
# 演示了如何将句子中的'dog' 替换为'cat'：
# >>> message = "I really like dogs."
# >>> message.replace('dog', 'cat')
# 'I really like cats.'
# 读取你刚创建的文件learning_python.txt中的每一行， 将其中的Python都替换为另一门语言的名称， 如C。 将修改后的各行都打印到屏幕上。
f_name = 'msg/learning_Python.txt'
with open(f_name) as f_name1:
lines = f_name1.readlines()
for line in lines:
c = line.replace('Python','C++')
print(c)
# 10-3 访客 ： 编写一个程序， 提示用户输入其名字； 用户作出响应后， 将其名字写入到文件guest.txt中。
name_info = 'msg/name_info_10_3.txt'
with open(name_info, 'r+') as name_info1:
while True:
name_msg = input('请输入你的姓名：')
if name_msg == 'quit':
break
elif name_msg == 'cls':
name_info1.truncate()
break
else:
name_info1.write('我的名字叫：' + name_msg + '\n')
# 10-4 访客名单 ： 编写一个while 循环， 提示用户输入其名字。 用户输入其名字后， 在屏幕上打印一句问候语，
# 并将一条访问记录添加到文件guest_book.txt中。 确保这个文件中的每条记录都独占一行。
f_name = 'msg/name_info_10_4.txt'
with open(f_name,'a') as f_name1:
while True:
msg10_4 = input('请输入你的姓名：')
if msg10_4 == 'quit':
break
elif msg10_4 == 'cls':
f_name1.truncate()
break
else:
print('你好！' + msg10_4)
f_name1.write('登录的人是： '+ msg10_4 + '\n')
# 10-5 关于编程的调查 ： 编写一个while 循环， 询问用户为何喜欢编程。 每当用户输入一个原因后， 都将其添加到一个存储所有原因的文件中。
f_name = 'msg/name_info_10-5.txt'
with open(f_name, 'a') as f_name1:
while True:
inp = input('请输入你喜欢编程的原因：（输入quit退出）')
if inp == 'quit':
break
elif inp == '':
print('请不要不写字！会浪费地方的亲！')
else:
f_name1.write(inp + '\n')
# 10-6 加法运算 ： 提示用户提供数值输入时， 常出现的一个问题是， 用户提供的是文本而不是数字。 在这种情况下， 当你尝试将输入转换为整数时， 将引
# 发TypeError 异常。 编写一个程序， 提示用户输入两个数字， 再将它们相加并打印结果。
# 在用户输入的任何一个值不是数字时都捕获TypeError 异常， 并打印一条友好的错误消息。 对你编写的程序进行测试： 先输入两个数字， 再输入一些文本而不是数字。
try:
inp_msg = input('请输入数字：')
inp_msg_toInt = int(inp_msg)
except ValueError:
print('只能输入整型')
else:
print(inp_msg_toInt)
# 10-7 加法计算器 ： 将你为完成练习10-6而编写的代码放在一个while 循环中， 让用户犯错（输入的是文本而不是数字） 后能够继续输入数字。
while True:
try:
inp_msg = input('请输入数字：')
inp_msg_toInt = int(inp_msg)
except ValueError:
print('只能输入整型')
else:
print(inp_msg_toInt)
break
# 10-8 猫和狗 ： 创建两个文件cats.txt和dogs.txt， 在第一个文件中至少存储三只猫的名字， 在第二个文件中至少存储三条狗的名字。 编写一个程序， 尝试读取这些文件，
# 并将其内容打印到屏幕上。 将这些代码放在一个try-except 代码块中， 以便在文件不存在时捕获FileNotFound 错误， 并打印一条友好的消息。 将其中一个文件
# 移到另一个地方， 并确认except 代码块中的代码将正确地执行。
##########读、写、清屏函数，不用try，直接造##################
f_name_a = 'msg/cats.txt'
f_name_b = 'msg/dogs.txt'
def write(f_name_x,msg):
with open(f_name_x,'a') as f:
f.write(msg)
def read(f_name_x):
with open(f_name_x) as f:
con = f.read()
print(con.rstrip())
def clear(f_name_x):
with open(f_name_x,'w') as f:
f.truncate()
clear(f_name_a)
clear(f_name_b)
write(f_name_a,'cat1\n')
write(f_name_a,'cat2\n')
write(f_name_a,'cat3\n')
write(f_name_b,'dog1\n')
write(f_name_b,'dog2\n')
write(f_name_b,'dog3\n')
read(f_name_a)
read(f_name_b)
##########正确答案############
def open_file(f_name):
try:
with open(f_name) as f_n:
con = f_n.read()
except FileNotFoundError:
print('404 not found！')
else:
print(con.rstrip())
ur_list = [ 'msg/cats.txt', 'msg/dogs.txt']
for i in ur_list:
open_file(i)
# 10-9 沉默的猫和狗 ： 修改你在练习10-8中编写的except 代码块， 让程序在文件不存在时一言不发。
def open_file(f_name):
try:
with open(f_name) as f_n:
con = f_n.read()
except FileNotFoundError:
pass
else:
print(con.rstrip())
ur_list = [ 'msg/cats.txt', 'msg/dogs.txt']
for i in ur_list:
open_file(i)
# 10-10 常见单词 ： 访问项目Gutenberg（http://gutenberg.org/ ） ， 并找一些你想分析的图书。 下载这些作品的文本文件或将浏览器中的原始文本复制到文本文件中。
# 你可以使用方法count() 来确定特定的单词或短语在字符串中出现了多少次。 例如， 下面的代码计算'row' 在一个字符串中出现了多少次：
# >>> line = "Row, row, row your boat"
# >>> line.count('row')
# 2 >
# >> line.lower().count('row')
# 3 请
# 注意， 通过使用lower() 将字符串转换为小写， 可捕捉要查找的单词出现的所有次数， 而不管其大小写格式如何。
# 编写一个程序， 它读取你在项目Gutenberg中获取的文件， 并计算单词'the' 在每个文件中分别出现了多少次。
f_name = 'msg/ruby.txt'
with open(f_name,encoding='utf-8') as f_n:
con = f_n.read()
a = con.count('the')
print(a)
# 10-11 喜欢的数字 ： 编写一个程序， 提示用户输入他喜欢的数字， 并使用json.dump() 将这个数字存储到文件中。 再编写一个程序， 从文件中读取这个值， 并打印
# 消息“I know your favorite number! It's _____.”。
import json
f_name = 'msg/inp_10_11.json'
msg_inp = input('请输入您喜欢的数字：')
with open(f_name,'w') as fn:
json.dump(msg_inp,f_n)
with open(f_name) as fn1:
c = json.load(f_n)
print('I know your favorite number! It\'s '+ c)
# 10-12 记住喜欢的数字 ： 将练习10-11中的两个程序合而为一。 如果存储了用户喜欢的数字， 就向用户显示它， 否则提示用户输入他喜欢的数字并将其存储到文件中。
# 运行这个程序两次， 看看它是否像预期的那样工作。
import json
# 如果以前存储了用户名， 就加载它
# 否则， 就提示用户输入用户名并存储它
filename = 'msg/fav_numb.json'
try:
with open(filename) as f_obj:
fav_num = json.load(f_obj)
except FileNotFoundError:
fav_num = input("请输入你喜欢的数字：")
with open(filename, 'a') as f_obj:
json.dump(fav_num, f_obj)
print("你喜欢的数字：" + fav_num + "!")
else:
print("你喜欢的数字：" + fav_num + "!")
# 10-13 验证用户 ： 最后一个remember_me.py版本假设用户要么已输入其用户名， 要么是首次运行该程序。 我们应修改这个程序， 以应对这样的情形： 当前和最后一次
# 运行该程序的用户并非同一个人。
# 为此， 在greet_user() 中打印欢迎用户回来的消息前， 先询问他用户名是否是对的。 如果不对， 就调用get_new_username() 让用户输入正确的用户名。
import json
def get_sorted_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():
username = get_sorted_username()
if username:
result = input(username + "is right?")
if result == 'y':
print("Welcom back,", username, "!")
else:
username = get_new_username()
print("Welcom back,", username, "!")
else:
username = get_new_username()
print("We'll remember you when you come back,", username, "!")
if __name__ == "__main__":
greet_user()
结尾
嗯哼！！基础知识点案例题目分享到这里就结束了哈！下次分享的一些案例的题目会慢慢变难滴 ！
你们都做的出来嘛？？！爬虫案例、数据分析......等下一次啦！
