《Python编程：从入门到实践》课后习题及答案

# 2-1 简单消息： 将一条消息存储到变量中， 再将其打印出来。
var = 'hello_world!'
print(var)

# 2-2 多条简单消息： 将一条消息存储到变量中，将其打印出来； 
# 再将变量的值修改为一条新消息， 并将其打印出来。
var = 'hello_world!'
print(var)
var = 'hello_python!'
print(var)

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

# 2-4 调整名字的大小写： 将一个人名存储到一个变量中， 再以小写、 大写和首字母大写的方式显示这个人名。
user_name = 'Eric'
print(user_name.lower())
print(user_name.upper())
print(user_name.title())

# 2-5 名言： 找一句你钦佩的名人说的名言， 将这个名人的姓名和他的名言打印出来。 输出应类似于下面这样（包括引号） ：
Albert Einstein once said, “A person who never made a mistake never tried anything new.”
print('Albert Einsteinonce said,"A person who never made a mistake never tried anything new."')

# 2-6 名言2： 重复练习2-5， 但将名人的姓名存储在变量famous_person 中， 再创建要显示的消息， 
# 并将其存储在变量message 中， 然后打印这条消息。
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() 对人名进行处理， 并将结果打印出来。
user_name = ' Eric '
print('\t'+ user_name.lstrip() + '\n\n')
print('\t'+ user_name.rstrip() + '\n\n')
print('\t'+ user_name.strip() + '\n\n')

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

# 2-9 最喜欢的数字： 将你最喜欢的数字存储在一个变量中， 再使用这个变量创建一条消息， 
# 指出你最喜欢的数字， 然后将这条消息打印出来。
fav_nub = 0
print('我最喜欢的数字是：' + str(fav_nub) +'!')

# 2-10 添加注释： 选择你编写的两个程序， 在每个程序中都至少添加一条注释。 
# 如果程序太简单， 实在没有什么需要说明的， 就在程序文件开头加上你的姓名和当前日期， 再用一句话阐述程序的功能。
var = 'hello_world!'
这句是将hello_world!字符串赋值给变量var
print(var)
将var变量打印出来

# 2-11 Python之禅： 在Python终端会话中执行命令import this ， 并粗略地浏览一下其他的指导原则。
①win+r 打开运行窗口
②输入cmd打开命令提示符
③输入python进入cpython
④输入import this
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!

# 3-1 姓名： 将一些朋友的姓名存储在一个列表中， 并将其命名为names 。 
# 依次访问该列表中的每个元素， 从而将每个朋友的姓名都打印出来。
names = ['张三','李四','王五']
print(names[0])
print(names[1])
print(names[2])


# 3-2 问候语： 继续使用练习3-1中的列表， 但不打印每个朋友的姓名， 而为每人打印一条消息。 
# 每条消息都包含相同的问候语， 但抬头为相应朋友的姓名。
names = ['张三','李四','王五']
print(names[0] + ',你好！')
print(names[1] + ',你好！')
print(names[2] + ',你好！')



# 3-3 自己的列表： 想想你喜欢的通勤方式， 如骑摩托车或开汽车， 并创建一个包含多种通勤方式的列表。 根
# 据该列表打印一系列有关这些通勤方式的宣言， 如“I wouldlike to own a Honda motorcycle”。
travel_mode = ['小汽车','摩托车','自行车']
print('我想拥有一辆：' + travel_mode[0])
print('我想拥有一辆：' + travel_mode[1])
print('我想拥有一辆：' + travel_mode[2])

# 3-4 嘉宾名单 ： 如果你可以邀请任何人一起共进晚餐（无论是在世的还是故去的），你会邀请哪些人？ 
# 请创建一个列表， 其中包含至少3个你想邀请的人； 然后， 使用这个列表打印消息， 邀请这些人来与你共进晚餐。
inv_list = ['马云','马化腾','李彦宏']
for inv_name in inv_list:
	print('尊敬的：' + inv_name + '（先生/女士），诚挚的邀请您参加今晚的宴会！')

# 3-5 修改嘉宾名单 ： 你刚得知有位嘉宾无法赴约， 因此需要另外邀请一位嘉宾。
# 以完成练习3-4时编写的程序为基础， 在程序末尾添加一条print 语句， 指出哪位嘉宾无法赴约。
# 修改嘉宾名单， 将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。
# 再次打印一系列消息， 向名单中的每位嘉宾发出邀请。
inv_list = ['马云','马化腾','李彦宏']
print(inv_list[0] + '因故无法赴宴！')
inv_list[0] = 'jack_Ma'
for inv_name in inv_list:
	print('尊敬的：' + inv_name + '（先生/女士），诚挚的邀请您参加今晚的宴会！')
	#这题出的真有毛病，马云马化腾要是都缺席了，李彦宏就要收三次短信，我要是李彦宏第一个开除你……



# 3-6 添加嘉宾 ： 你刚找到了一个更大的餐桌， 可容纳更多的嘉宾。 请想想你还想邀请哪三位嘉宾。
# 以完成练习3-4或练习3-5时编写的程序为基础， 在程序末尾添加一条print 语句， 指出你找到了一个更大的餐桌。
# 使用insert() 将一位新嘉宾添加到名单开头。
# 使用insert() 将另一位新嘉宾添加到名单中间。
# 使用append() 将最后一位新嘉宾添加到名单末尾。
# 打印一系列消息， 向名单中的每位嘉宾发出邀请。
inv_list = ['马云','马化腾','李彦宏']
inv_list.insert(0,'雷军')
inv_list.insert(2,'柳传志')
inv_list.append('赵本山')
for inv_name in inv_list:
	print('尊敬的：' + inv_name + '（先生/女士），诚挚的邀请您参加今晚的宴会！')

# 3-7 缩减名单 ： 你刚得知新购买的餐桌无法及时送达， 因此只能邀请两位嘉宾。
# 以完成练习3-6时编写的程序为基础， 在程序末尾添加一行代码， 打印一条你只能邀请两位嘉宾共进晚餐的消息。
# 使用pop() 不断地删除名单中的嘉宾， 直到只有两位嘉宾为止。 每次从名单中弹出一位嘉宾时， 都打印一条消息， 
# 让该嘉宾知悉你很抱歉， 无法邀请他来共进晚餐。
# 对于余下的两位嘉宾中的每一位， 都打印一条消息， 指出他依然在受邀人之列。
# 使用del 将最后两位嘉宾从名单中删除， 让名单变成空的。 打印该名单， 核实程序结束时名单确实是空的。
print('--------------------')
inv_list = ['马云','马化腾','李彦宏']
inv_list.insert(0,'雷军')
inv_list.insert(2,'柳传志')
inv_list.append('赵本山')
for inv_name in inv_list:
	print('尊敬的：' + inv_name + '（先生/女士），诚挚的邀请您参加今晚的宴会！')
print('抱歉，只能邀请两位嘉宾共进晚餐')
n = int(len(inv_list))
while n > 2:
	last_name = inv_list.pop()
	print(last_name + '，别来了')
	n = n-1
for inv_name in inv_list:
	print(inv_name + '接着来吧！混蛋')
#急着下班，这样写有点乱，建议加个中间list_temp

# 3-8 放眼世界 ： 想出至少5个你渴望去旅游的地方。
# 将这些地方存储在一个列表中， 并确保其中的元素不是按字母顺序排列的。91
# 按原始排列顺序打印该列表。 不要考虑输出是否整洁的问题， 只管打印原始Python列表。92
# 使用sorted() 按字母顺序打印这个列表， 同时不要修改它。93
# 再次打印该列表， 核实排列顺序未变。94
# 使用sorted() 按与字母顺序相反的顺序打印这个列表， 同时不要修改它。9596
# 再次打印该列表， 核实排列顺序未变。97
# 使用reverse() 修改列表元素的排列顺序。 打印该列表， 核实排列顺序确实变了。9899
# 使用reverse() 再次修改列表元素的排列顺序。 打印该列表， 核实已恢复到原来的排列顺序。100101
# 使用sort() 修改该列表， 使其元素按字母顺序排列。 打印该列表， 核实排列顺序确实变了。
# 使用sort() 修改该列表， 使其元素按与字母顺序相反的顺序排列。 打印该列表， 核实排列顺序确实变了。
traver_place = ['BeiJing','NanJing','XiAn','LuoYang','GuangZhou']
print(traver_place)
print(sorted(traver_place))
print(traver_place)
traver_place.reverse()
print(sorted(traver_place))
print(traver_place)
traver_place.reverse()
print(traver_place)
traver_place.reverse()
print(traver_place)
traver_place.sort()  
print(traver_place)
traver_place.sort(reverse=True)  
print(traver_place)
#什么神经病题目，可能会有遗漏，但是不会报错

# 3-9 晚餐嘉宾 ： 在完成练习3-4~练习3-7时编写的程序之一中， 使用len() 打印一条消息， 指出你邀请了多少位嘉宾来与你共进晚餐。
inv_list = ['马云','马化腾','李彦宏']
print('共邀请了：' + str(len(inv_list)) + '位宾客！')

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

# 4-1 比萨 ： 想出至少三种你喜欢的比萨， 将其名称存储在一个列表中， 
# 再使用for 循环将每种比萨的名称都打印出来。
# 修改这个for 循环， 使其打印包含比萨名称的句子， 而不仅仅是比萨的名称。 
# 对于每种比萨， 都显示一行输出， 如“I like pepperoni pizza”。
# 在程序末尾添加一行代码， 它不在for 循环中， 指出你有多喜欢比萨。 
# 输出应包含针对每种比萨的消息， 还有一个总结性句子， 如“I really love pizza!”。
pizzas = ['pizzaA','pizzaB','pizzaC']
for temp in pizzas:
	print(temp)
for temp2 in pizzas:
	print('I like:' + temp2 +'!')
print('老喜欢吃披萨了，比如：' + str(pizzas) + ',I really love pizza!' )

# 4-2 动物 ： 想出至少三种有共同特征的动物， 将这些动物的名称存储在一个列表中， 再使用for 循环将每种动物的名称都打印出来。
# 修改这个程序， 使其针对每种动物都打印一个句子， 如“A dog would make a great pet”。
# 在程序末尾添加一行代码， 指出这些动物的共同之处， 如打印诸如“Any of these animals would make a great pet!”这样的句子。
animals = ['dog','cat','bird']
for temp in animals:
	print(temp)
print('A '+ animals[0] + ' would make a great pet1')
print('A '+ animals[1] + ' would make a great pet2')
print('A '+ animals[2] + ' would make a great pet3')
print('Any of these animals would make a great pet')

# 4-3 数到20 ： 使用一个for 循环打印数字1~20（含） 。
temp = list(range(1,21))
for t in temp:
	print(t)

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

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

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

# 4-7 3的倍数 ： 创建一个列表， 其中包含3~30内能被3整除的数字； 再使用一个for 循环将这个列表中的数字都打印出来。
temp = list(range(3,31))
temp2 = []
for t in temp:
	if t % 3 == 0:
		temp2.append(t)
print(temp2)
# 4-8 立方 ： 将同一个数字乘三次称为立方。 例如， 在Python中， 2的立方用2**3 表示。 请创建一个列表， 其中包含前10个整数（即1~10） 
# 的立方， 再使用一个for 循环将这些立方数都打印出来。
temp = list(range(1,11,1))
temp2 = []
for t in temp:
	t = t ** 2
	temp2.append(t)
print(temp2)
#4-8方法2
for value in range(3,31,3):  
    print(value)  


# 4-9 立方解析 ： 使用列表解析生成一个列表， 其中包含前10个整数的立方。
lists = [value**3 for value in range(1,11)]  
print(lists)
	
# 4-10 切片 ： 选择你在本章编写的一个程序， 在末尾添加几行代码， 以完成如下任务。
# 打印消息“The first three items in the list are:”， 再使用切片来打印列表的前三个元素。
# 打印消息“Three items fromthe middle of the list are:”， 再使用切片来打印列表中间的三个元素。
# 打印消息“The last three items in the list are:”， 再使用切片来打印列表末尾的三个元素。
lists = ['1','2','3','4','5','6','7'] 
print('The first three items in the list are:')
temp1 = lists[:3]
for t1 in temp1:
	print(t1)
print('Three items fromthe middle of the list are:' )
temp2 = lists[2:5]
for t2 in temp2:
	print(t2)
print('Three items fromthe middle of the list are:')
temp3 = lists[-3:]
for t3 in temp3:
	print(t3)
	
# 4-11 你的比萨和我的比萨 ： 在你为完成练习4-1而编写的程序中， 创建比萨列表的副本， 并将其存储到变量friend_pizzas 中， 
# 再完成如下任务。在原来的比萨列表中添加一种比萨。在列表friend_pizzas 中添加另一种比萨。
# 核实你有两个不同的列表。 为此， 打印消息“My favorite pizzas are:”， 再使用一个for 循环来打印第一个列表； 
# 打印消息“My friend's favorite pizzas are:”， 再使用一个for 循环来打印第二个列表。 核实新增的比萨被添加到了正确的列表中。
my_pizzas = ['pizzaA','pizzaB','pizzaC']
friend_pizzas = my_pizzas[:]
my_pizzas.append('my_pizzaD')
friend_pizzas.append('friend_pizzaD')
print('My favorite pizzas are: ')
for temp in my_pizzas:
	print(temp)
print('My friend\'s favorite pizzas are: ')
for temp in friend_pizzas:
	print(temp)


# 4-12 使用多个循环 ： 在本节中， 为节省篇幅， 程序foods.py的每个版本都没有使用for 循环来打印列表。 请选择一个版本的foods.py， 
# 在其中编写两个for 循环， 将各个食品列表都打印出来。	
my_foods = ['pizza', 'falafel', 'carrot cake']	
for t in my_foods:
	print(t)
	
# 4-13 自助餐 ： 有一家自助式餐馆， 只提供五种简单的食品。 请想出五种简单的食品， 并将其存储在一个元组中。
# 使用一个for 循环将该餐馆提供的五种食品都打印出来。
# 尝试修改其中的一个元素， 核实Python确实会拒绝你这样做。
# 餐馆调整了菜单， 替换了它提供的其中两种食品。 请编写一个这样的代码块： 给元组变量赋值， 
# 并使用一个for 循环将新元组的每个元素都打印出来。
food = ('冰淇淋','苹果','牛肉','羊肉','火锅')	
for f in food:
	print(f)
food[0] = '1'
food = ('1','2','牛肉','羊肉','火锅')	
for f in food:
	print(f)
	
# 4-14 PEP 8 ： 请访问https://python.org/dev/peps/pep-0008/ ， 阅读PEP 8格式设置指南。 
# 当前， 这些指南适用的不多， 但你可以大致浏览一下。
#略……………………

# 4-15 代码审核 ： 从本章编写的程序中选择三个， 根据PEP 8指南对它们进行修改。
# 每级缩进都使用四个空格。 对你使用的文本编辑器进行设置， 使其在你按Tab键时都插入四个空格； 
# 如果你还没有这样做， 现在就去做吧（有关如何设置， 请参阅附录B） 。
# 每行都不要超过80字符。 对你使用的编辑器进行设置， 使其在第80个字符处显示一条垂直参考线。
# 不要在程序文件中过多地使用空行。
#略……………………
	

# 5-1 条件测试 ： 编写一系列条件测试； 将每个测试以及你对其结果的预测和实际结果都打印出来。 你编写的代码应类似于下面这样：
# 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个。
car = 'bmw'
cars = ['bmw','audi']
#T
print(car == 'bmw')
#F
print(car != 'bmw')
#T
print(car == car)
#F
print(car == car.title())
#T
print(car == 'bmw' or  car == 'audi')
#F
print(car == 'bmw' and car == 'audi')
#T
print(int(len(car)) == int(len('bmw')))
#F
print(int(len(car)) == int(len('audi')))
#T
print('bmw' in cars)
#F
print('audi' not in cars)

# 6-1 人 ： 使用一个字典来存储一个熟人的信息， 包括名、 姓、 年龄和居住的城市。 
# 该字典应包含键first_name 、 last_name 、 age 和city 。 将存储在该字典中的每项信息都打印出来。
mayun = {'first_name':'Ma','last_name':'Yun','age':'54','city':'HangZhou'}
for key,value in mayun.items():
	print('key:' + key)
	print('value:' + value)


# 6-2 喜欢的数字 ： 使用一个字典来存储一些人喜欢的数字。 请想出5个人的名字， 
# 并将这些名字用作字典中的键； 想出每个人喜欢的一个数字， 并将这些数字作为值存
# 储在字典中。 打印每个人的名字和喜欢的数字。 为让这个程序更有趣， 通过询问朋友确保数据是真实的。
dics = {'jack':'1','john':'2','kaiven':'3','popo':'4','lili':'5'}
for k,v in dics.items():
	print(k + '最喜欢的数字是： ' + v)


# 6-3 词汇表 ： Python字典可用于模拟现实生活中的字典， 但为避免混淆， 我们将后者称为词汇表。
# 想出你在前面学过的5个编程词汇， 将它们用作词汇表中的键， 并将它们的含义作为值存储在词汇表中。
# 以整洁的方式打印每个词汇及其含义。 为此， 你可以先打印词汇， 在它后面加上一个冒号， 再打印词汇的含义； 
# 也可在一行打印词汇， 再使用换行符（\n ） 插入一个空行， 然后在下一行以缩进的方式打印词汇的含义。
#我真是良心up主啊，看到了6-4，，又把6-3复杂的写了一遍………………
dics = {'list':'列表','var':'变量','int':'整型','boolean':'布尔','str':'字符串'}
print('dics[\'list\']'+':' + dics['list'])
print('dics[\'var\']'+':' + dics['var'])
print('dics[\'int\']'+':' + dics['int'])
print('dics[\'boolean\']'+':' + dics['boolean'])
print('dics[\'str\']'+':' + dics['str'])
	
	
# 6-4 词汇表2 ： 既然你知道了如何遍历字典， 现在请整理你为完成练习6-3而编写的代码， 
# 将其中的一系列print 语句替换为一个遍历字典中的键和值的循环。 确定该循环正确无误后， 
# 再在词汇表中添加5个Python术语。 当你再次运行这个程序时， 这些新术语及其含义将自动包含在输出中。
dics = {'list':'列表','var':'变量','int':'整型','boolean':'布尔','str':'字符串'}
for k,v in dics.items():
	print(k + ':' + v + '\n')

	
# 6-5 河流 ： 创建一个字典， 在其中存储三条大河流及其流经的国家。 其中一个键—值对可能是'nile': 'egypt' 。
# 使用循环为每条河流打印一条消息， 如“The Nile runs through Egypt.”。
# 使用循环将该字典中每条河流的名字都打印出来。
# 使用循环将该字典包含的每个国家的名字都打印出来。
rivers = {'nile':'egypt','huanghe':'china','changjiang':'china'}
for k , v in rivers.items():
	print('The ' + k + ' runs through ' + v + ' .')
for k in rivers.keys():
	print(k)
for v in rivers.values():
	print(v)


# 6-6 调查 ： 在6.3.1节编写的程序favorite_languages.py中执行以下操作。
# 创建一个应该会接受调查的人员名单， 其中有些人已包含在字典中， 而其他人未包含在字典中。
# 遍历这个人员名单， 对于已参与调查的人， 打印一条消息表示感谢。 对于还未参与调查的人， 打印一条消息邀请他参与调查。
favorite_languages = {
	'amada':'C',
	'jacky':'java',
	'frank':'c++',
	'polly':'php',
	'maily':'.net'
	}
lists = ['amada','jacky','mayun','admin']
temp = []
for k in favorite_languages.keys():
	temp.append(k)
print(temp)
for s in lists:
	if s in temp:
		print('1')
	else:
		print ('2')
		
# 6-7 人 ： 在为完成练习6-1而编写的程序中， 再创建两个表示人的字典， 然后将这三个字典都存储在一个名为people 的列表中。 
# 遍历这个列表， 将其中每个人的所有信息都打印出来。
mayun0 = {'first_name':'Ma0','last_name':'Yun0','age':'540','city':'HangZhou0'}
mayun1 = {'first_name':'Ma1','last_name':'Yun1','age':'541','city':'HangZhou1'}
mayun2 = {'first_name':'Ma2','last_name':'Yun','age':'542','city':'HangZhou2'}
people = [mayun0,mayun1,mayun2]
# print(people)
for i in people[:]:
	print(i)




# 6-8 宠物 ： 创建多个字典， 对于每个字典， 都使用一个宠物的名称来给它命名； 在每个字典中， 包含宠物的类型及其主人的名字。 
# 将这些字典存储在一个名为pets的列表中， 再遍历该列表， 并将宠物的所有信息都打印出来。
dog ={'name':'dog1','age':'3'}
cat ={'name':'cat1','age':'4'}
bird ={'name':'bird1','age':'1'}
pets = [dog,cat,bird]
for p in pets:
	print(p)

# 6-9 喜欢的地方 ： 创建一个名为favorite_places 的字典。 在这个字典中， 将三个人的名字用作键； 对于其中的每个人， 
# 都存储他喜欢的1~3个地方。 为让这个练习更有趣些， 可让一些朋友指出他们喜欢的几个地方。 遍历这个字典， 
# 并将其中每个人的名字及其喜欢的地方打印出来。
favorite_places = {'jack':'beijing','paul':'shanghai','lili':'hangzhou'}
for fp in favorite_places.items():
	print(fp)


# 6-10 喜欢的数字 ： 修改为完成练习6-2而编写的程序， 让每个人都可以有多个喜欢的数字， 然后将每个人的名字及其喜欢的数字打印出来。
dics = {'jack':['1','2'],'john':['3','4']}
for k,v in dics.items():
	print(k + '最喜欢的数字是： ' )
	for v1 in v:
		print(v1)



# 6-11 城市 ： 创建一个名为cities 的字典， 其中将三个城市名用作键； 对于每座城市， 都创建一个字典， 
# 并在其中包含该城市所属的国家、 人口约数以及一个有关该城市的事实。 在表示每座城市的字典中， 
# 应包含country 、 population 和fact 等键。 将每座城市的名字以及有关它们的信息都打印出来。
cities = {'beijing':{'country':'china','population':'100','fact':'超级堵'},'guangzhou':{'country':'china','population':'300','fact':'超级堵2'},'shanghai':{'country':'china','population':'200','fact':'超级堵1'}}
for k,v in cities.items():
	print('城市：'+k+ '的信息： ')
	for k1,v1 in v.items():
		print(k1,v1)


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

#本章节代码中暂不涉及try-catch，所以默认为用户输入的符合所需要的输入类型


# 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)

# 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)

# 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 的文档

# 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()

#!/usr/bin/env	python
#-*-coding:utf8-*-
def format_name (first,last,middle=''):
	""" 格式化一个姓名"""
	
	if middle:
		fullname = first +' '+middle+' '+last
	else:
		fullname = first +' '+last
	return fullname.title()
def format_city (city,country,population=''):
	""" 格式化一个国家和城市 """
	if population:
		city_country = city +','+country+' - population'+' '+population
	else:                      
		city_country = city +','+country
	return city_country.title()

#!/usr/bin/env	python
#-*-condig:utf8-*-
import unittest
from name_function import format_name
from name_function import format_city
class NameTestCase(unittest.TestCase):
	""" 测试name_function.py """
	def test_first_last_name (self):
		""" 能够正确的处理像james hardon这样的姓名吗？ """
		formattedname = format_name('james','hardon')
		self.assertEqual(formattedname,'James Hardon')
	def test_first_middle_last_name (self):
		""" 能够正确的处理像james hardon ding这样的姓名吗？"""
		formattedname = format_name('james','hardon','ding')
		self.assertEqual(formattedname,'James Ding Hardon')
	def	test_city_country(self):
		"""能够正确的处理像santiago,chile"""
		formattedcity = format_city('santiago','chile')
		self.assertEqual(formattedcity,'Santiago,Chile')
	def test_city_country_population (self):
		""" 能够处理带人口的城市吗？ """
		formattedcity = format_city('santiago','chile',population='500000')
		self.assertEqual(formattedcity,'Santiago,Chile - Population 500000')
unittest.main()

#!/usr/bin/env	python
#-*-coding:utf8-*-
class Employee:
	""" 收集雇员信息 """
	def __init__ (self,first,last,salary):
		""" 雇员信息 """
		self.first = first
		self.last = last
		self.salary = salary
	def give_raise (self,addsalary=5000):
		""" Function doc """
		self.salary+=addsalary
		

#!/usr/bin/env	python
#-*-coding:utf8-*-
import unittest
from Employee import Employee
class EmployeeTestCase(unittest.TestCase):
	""" 测试不同的雇员信息 """

	def setUp (self):
		""" 初始化雇员信息 """
		self.formatted_default = Employee('ding','yuanxue',1000)
	def test_give_default_raise (self):
		""" 默认加薪 """
		self.formatted_default.give_raise()
		self.assertEqual(self.formatted_default.salary,6000)
	def test_give_coustom_raise (self):
		"""特殊加薪"""
		self.formatted_default.give_raise(8000)
		self.assertEqual(self.formatted_default.salary,9000)	
	
unittest.main()