三剑客python自学笔记--03

Python编程：从入门到实践 链接：https://pan.baidu.com/s/1kbseKVhMm-O9EphvF4V3XA 
提取码：3a4r

Python编程快速上手—让繁琐工作自动化 链接：https://pan.baidu.com/s/1knrfzj22huEBWWdQBnRdXA 
提取码：8g5k

Python极客项目编程 链接：链接：https://pan.baidu.com/s/1Jo7lYyTEFnpnG3mou7uPmw 
提取码：97dm
 

6-7章笔记：

#一个简单的字典
alien_0 = {'color':'green','points':5}#在Python中，字典用放在花括号{}中的一系列键——值对表示
##键—值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。
print(alien_0['color'])
print(alien_0['points'])
#字典alien_0 存储了外星人的颜色和点数。使用两条print 语句来访问并打印这些信息

#使用字典
#在Python中，字典 是一系列键—值对 。每个键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符
#串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

alien_0 = {"color":"green","points":5}

new_points = alien_0['points']#要获取与键相关联的值，可依次指定字典名和放在方括号内的键
print("You just earned " + str(new_points) + " points!")

#添加键——值对，要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值
alien_0 = {'color':"green",'points':5}
print(alien_0)
#在这个字典中新增了两个键—值对
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
#书上打印结果x_position和y_position两个位置反了，我这边打印的没毛病
#我这打印的结果
#{'color': 'green', 'points': 5}
#{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}

#注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对的添加顺序，而只关心键和值之间的关联关系。

#创建一个空字典
alien_0 = {}

alien_0['color'] = 'green'
alien_0['points'] = 5

print(alien_0)
#使用字典来存储用户提供的数据或在编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典

#修改字典中的值
#要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。
alien_0 = {'color':'green'}
print("The alien is " + alien_0['color'] + ".")

alien_0["color"] = 'yellow'#将与键'color' 相关联的值改为'yellow'
print("The alien is now " + alien_0['color'] + '.')

print('\n\n')

alien_0 = {'x_position':0,'y_position':25,'speed':'fast'}
print("Original x-position: " + str(alien_0['x_position']))

#向右移动外星人
#据外星人当前速度决定将其移动多远
if alien_0['speed'] == 'slow':
	x_increment = 1
elif alien_0['speed'] == 'medium':
	x_increment = 2
else:
	#这个外星人的速度一定很快
	x_increment = 3
	
#新位置等于老位置加上增量
alien_0['x_position'] = alien_0['x_position'] + x_increment

print("New x-position: " + str(alien_0['x_position']))

#删除键——值对
alien_0 = {'color':'green','points':5}
print(alien_0)

del alien_0['points']#使用del 语句时，必须指定字典名和要删除的键。
print(alien_0)

#由类似对像组成的字典
#在前面的示例中，字典存储的是一个对象（游戏中的一个外星人）的多种信息，但你也可以使用字典来存储众多对象的同一种信息
favorite_languages = {'jen':'python','sarah':'c','edeard':'ruby','phil':'python',}
#这最后多打一个,不会报错（列表，元组都会报错）
#也可以这样输入：
favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edeard':'ruby',
	'phil':'python',
	}
#换行续写，建议缩进，提高可读性（不缩进也不会报错）
#确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键—值对，并在它后面加上一个逗号。
#注意 对于较长的列表和字典，大多数编辑器都有以类似方式设置其格式的功能。对于较长的字典，还有其他一些可行的格式设置方式，因此在
#你的编辑器或其他源代码中，你可能会看到稍微不同的格式设置方式。

print("Sarah's favorite language is " +
	favorite_languages['sarah'].title() +
	".")#适当缩进，提高可读性

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

#遍历字典
user_0 = {
	'username':'efermi',
	'first':'enrico',
	'last':'fermi',
	}
#遍历：
for key, value in user_0.items():#for 语句的第二部分包含字典名和方法items(),它返回一个键—值对列表
	print("\nKey: " + key)
	print("Value: " + value)
#要编写用于遍历字典的for 循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使用任何名称。
#下面的代码使用了简单的变量名，这完全可行：
#for k, v in user_0.items()
#注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。
#上面这一条，我的返回顺序和存储顺序是一样的

favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}

for name,language in favorite_languages.items():#先键后值
	print(name.title() + "'s favorite language is " +
		language.title() + ".")#注意这块的缩进

#遍历字典中的所有键
#在不需要使用字典中的值时，方法keys()很有用
favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}
	
for name in favorite_languages.keys():#让Python提取字典favorite_languages 中的所有键，并依次将它们存储到变量name 中
	print(name.title())
#遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys(): 替换为
#for name in favorite_languages: ，输出将不变。

favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}

friends = ['phil','sarah']
for name in favorite_languages.keys():#keys()会返回一个包含字典中所有键的列表
	print(name.title())#书中的键是倒序打印的，也不知道为啥
	
	if name in friends:
		print(" Hi " + name.title() +
		", I see your favorite language is " +
		favorite_languages[name].title() + "!")

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'ruby',
	'phil': 'python',
	}

if 'erin' not in favorite_languages.keys():
	print("Erin, please take our poll!")

#按顺序遍历字典中的所有键
#在for循环中对返回的键进行排序，用函数sorted()
favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}

for name in sorted(favorite_languages.keys()):#让Python列出字典中的所有键，并在遍历前对这个列表进行排序。
	print(name.title() + ", thank you taking the poll.")

#遍历字典中的是所有值
favorite_languages = {
	'jen': 'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}

print("The following languages have been mentioned:")
for language in favorite_languages.values():
	print(language.title())#一个循环结束，自动换行
	
#使用方法values() ，它返回一个值列表，而不包含任何键		
#这种做法提取字典中所有的值，而没有考虑是否重复。
#涉及的值很少时，这也许不是问题，但如果被调查者很多，最终的列表可能包含大量的重复项。
#为剔除重复项，可使用集合（set）。集合 类似于列表，但每个元素都必须是独一无二的：

favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	'phil':'python',
	}
	
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
	print(language.title())
	
#结果是一个不重复的列表
#The following languages have been mentioned:
#Python
#C
#Ruby
#最后一个Python没了

#嵌套
#有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套

alien_0 = {'color':'green','points':5}
alien_1 = {'color':'yellow','points':10}
alien_2 = {'color':'red','points':15}

aliens = [alien_0,alien_1,alien_2]

#修改列表里的字典的值aliens[0]['color']

for alien in aliens:
	print(alien)
	
#更符合现实的情形是，外星人不止三个，且每个外星人都是使用代码自动生成的
#创建一个用于存储外星人的空列表
aliens = []

#创建30个绿色的外星人
for alien_number in range(30):#循环30次
	new_alien = {'color':'green','points':5,'speed':'slow'}
	aliens.append(new_alien)
	
for alien in aliens[:3]:
	if alien['color'] == 'green':
		alien['color'] = 'yellow'
		alien['speed'] = 'medium'
		alien['points'] = 10

#显示前5个外星人
for alien in aliens[:5]:
	print(alien)
print("...")

#显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))#len()显示列表长度，str()将整型转化为字符型

#在字典中存储列表
#存储所点比萨的信息
pizza = {
	'crust':'thick',
	'toppings':['mushrooms','extra cheese'],
	}
	
#概述所点的比萨
print("You ordered a " + pizza['crust'] + "-crust pizza " +
	"with the following toppings:")
	
for topping in pizza['toppings']:
	print("\t" + topping)
	
#每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表
favorite_languages = {
	'jen':['python','ruby'],
	'sarah':['c'],
	'edward':['ruby','go'],
	'phil':['python','haskell'],
	}
	
for name,languages in favorite_languages.items():#，name为键，languages为值，且这些值都是列表
	if len(languages) > 1:
		print("\n" + name.title() + "'s favorite language are:")
	else:
		print("\n" + name.title() + "'s favorite language is:")
	for language in languages:
			print("\t" + language.title())

#注意 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。

users = {
	'aeninstein':{
		'first':'albert',
		'last':'einstein',
		'location':'princeton',
		},
		
	'mcurie':{
		'first':'marie',
		'last':'curie',
		'location':'paris',
		},
		
	}
#修改字典里的字典里的值：users['mcurie']['first'] = 'zc'
		
for username,user_info in users.items():#username是键，键是字符串，user_info是值，值是字典
	print("\nUsername: " + username)
	full_name = user_info['first'] +  " " + user_info["last"]
	location = user_info['location']
	
	print("\tFull name: " + full_name.title())
	print("\tLocation: " + location.title())

#请注意，表示每位用户的字典的结构都相同，虽然Python并没有这样的要求，但这使得嵌套的字典处理起来更容易。
#倘若表示每位用户的字典都包含不同的键，for 循环内部的代码将更复杂。

#修改列表的键：
info = {'x':1.5,'y':2}

info['z'] = info.pop('x')#字典里的pop()是删除某个键及其对应的值，返回的是该键对应的值

print(info)

#用户输入和while循环

#函数input()的工作原理

#message = input("Tell me something,and I will repeat it back to you:")

#先打印()里的，再等待用户输入，再将用户输入的值赋予message 变量

#print(message)

#每当你使用函数input() 时，都应指定清晰而易于明白的提示，准确地指出你希望用户提供什么样的信息

#name = input("Please enter your name: ")
#print("Hello, " + name + "!")

#有时候，提示可能超过一行

#prompt = "if youo tell us who you are, we can personalize the messages you see."
#prompt += "\nWhat is your first name? "#运算符+= 在存储在prompt 中的字符串末尾附加一个字符串

#name = input(prompt)
#print("\nHello, " + name + "!")

#使用函数input()时，Python将用户输入解读为字符串
#age = input("How old are you? ")
#print(age >= 18)#你试图将输入作为数字使用，就会引发错误

#为解决这个问题，可使用函数int() ，它让Python将输入视为数值
#age = input("How old are you? ")
#age = int(age)

#print(age >= 18)

#实际使用的事例
#height = input("How tall are you, in inches?")
#height = int(height)

#if height >= 36:
#	print("\nYou're tall enough to ride!")
#else:
#	print("\nYou'll be able to ride when you're a little older.")

#将数值输入用于计算和比较前，务必将其转换为数值表示

#求摸运算符,求模运算符不会指出一个数是另一个数的多少倍，而只指出余数是多少
#number = input("Enter a number, and I'll tell you if it's even or odd: ")
#number = int(number)

#if number % 2 == 0:
#	print("\nThe number " + str(number) + " is even.")
#else:
#	print("\nThe number " + str(number) + " is odd.")

#While 循环
#for 循环用于针对集合中的每个元素都一个代码块，而while 循环不断地运行，直到指定的条件不满足为止

#你可以使用while 循环来数数，例如，下面的while循环从1数到5
current_number = 1
while current_number <= 5:#每一次循环都会换行打印
	print(current_number)
	current_number += 1

#让用户选择何时退出
#prompt = "\nTell me something, and I will repeat it back to you:"
#prompt += "\nEnter 'quit' to end the program."
#message = ""#将变量message 的初始值设置为空字符串"" ，让Python首次执行while 代码行时有可供检查的东西
#while message != 'quit':
#	message = input(prompt)
#	if message != 'quit':#程序在显示消息前将做简单的检查，仅在消息不是退出值时才打印它
#		print(message)

#使用标志
#在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。
#这个变量被称为标志 ，充当了程序的交通信号灯。
#你可让程序在标志为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。
#这样，在while 语句中就只需检查一个条件——标志的当前值是否为True 
#并将所有测试（是否发生了应将标志设置为False 的事件）都放在其他地方，从而让程序变得更为整洁。

#prompt = "\nTell me something, and I will repeat it back to you:"
#prompt += "\nEnter 'quit' to end the program."

#active = True#简化while语句，变量active 设置成了True，让程序最初处于活动状态
#while active:
#	message = input(prompt)
	
#	if message == 'quit':#我们在用户输入后使用一条if 语句来检查变量message 的值
#		active = False#如果用户输入的是'quit' ，我们就将变量active 设置为False ，这将导致while 循环不再继续执行
#	else:
#		print(message)#如果用户输入的不是'quit' ，我们就将输入作为一条消息打印出来

#使用break退出循环
#要立即退出while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break 语句
#prompt = "\nPlease enter the name of a city you have visited:"
#prompt += "\n(Enter 'quit' when you are finished.) "

#while True:#while True 打头的循环将不断运行，直到遇到break 语句。
#	city = input(prompt)
	
#	if city == 'quit':
#		break
#	else:
#		print("I'd love to go to " + city.title() + "!")

#注意 在任何Python循环中都可使用break 语句。例如，可使用break 语句来退出遍历列表或字典的for 循环。

#在循环中使用continue
#要返回到循环开头，并根据条件测试结果决定是否继续执行循环
#从1数到10，但只打印其中偶数的循环：
current_number = 0#为了能执行while循环
while current_number < 10:
	current_number += 1#改变标志的值
	if current_number % 2 ==0:#如果可被2整除，就执行continue语句，让Python忽略余下的代码，并返回循环的开头
		continue
	print(current_number)

#避免无限循环
x = 1
while x <= 5:
	print(x)
	x += 1#如果漏了这一条，程序将会无限执行下去，此时按Ctrl+C可终止
	
#注意 有些编辑器（如Sublime Text）内嵌了输出窗口，这可能导致难以结束无限循环，因此不得不关闭编辑器来结束无限循环

#使用while循环来处理列表和字典

#在列表之间移动元素
#for 循环是一种遍历列表的有效方式，但在for 循环中不应修改列表，否则将导致Python难以跟踪其中的元素。
#要在遍历列表的同时对其进行修改，可使用while 循环
#在列表之间移动元素

#首先，创建一个待验证用户列表和一个用于存储已验证用户的空列表
unconfirmed_users = ['alices','brian','candace']
confirmed_users = []

#验证每个用户，直到没有未验证用户为止
#将每个经过验证的列表都移到已验证用户列表
while unconfirmed_users:#当没有未验证用户时，unconfirmed_users为空，while循环此时就停止了
	current_user = unconfirmed_users.pop()
	
	print("Verifying user: " + current_user.title())
	confirmed_users.append(current_user)
	
#显示所有已验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
	print(confirmed_user.title())

#删除包含特定值的所有列表元素
pets = ['dog','cat','dog','goldfish','cat','rabbit','cat']
print(pets)

while 'cat' in pets:#当pets中没有'cat'时，循环结束
	pets.remove('cat')
	
print(pets)

#使用用户输入来填充字典
responses = {}

#设置一个标志，指出调查是否继续
polling_active = True#设置了一个标志（polling_active ），用于指出循环是否继续

while polling_active:
	#提示输入被调查者的名字和回答
	name = input("\nWhat is your name? ")
	response = input("Which mountain would you like to climb someday? ")
	
	#将答卷存储在字典中
	responses[name] = response 
	
	#看看是否还有人要参与调查
	repeat = input("Would you like to let another person respond? (yes/no) ")
	if repeat == 'no':
		polling_active = False
		
	#调查结束，显示结果
print("\n--- Poll Results ---")
for name,response in responses.items():
	print(name + "would like to climb " + response + ".")