Python 小白学习之：tuple 和 dict

元组 tuple
		元组是不可变的序列，同list一样，元组可以储存任意类型的数据的容器
	元组的表达方法：
		用小括号()括起来，单个元素括起来后加逗号(,)区分单个对象还是元组
	
	创建空元组的字面值方式：
		t = （）  # 创建一个空元组用t绑定
	创建非空元组的字面值
		t = 200,  # 创建一个只有数字200的元组用t绑定
		t = (20,) # 为了区别于（20），（20）是一个表达式
		t = (1,2,3)
		t = 100,200,300
		
	创建元组的错误示例：
		t = (20)  t绑定的是整数20，不是元组
		x, y ,z = (100,200,300)   这是赋值序列,x = 100,y = 200,z = 300
		x, y ,z = 100,200,300     这是赋值序列,x = 100,y = 200,z = 300
		x, y ,z = [100,200,300]   这是赋值序列,x = 100,y = 200,z = 300
		x, y ,z = "ABC"   这是序列赋值，不是元组 x = "A",y = "B",z = "c"
		x , y = y ,x      可以交换两个变量的绑定关系
	type(x) 函数返回x的类型
	如：s = "A"
		if type(x) is str:
			print("是字符串")
	
	元组的构造函数 tuple
	tuple()    #  生成一个空的元组，等同于()
	tuple(iterable)   # 用可迭代对象生活才能一个新的元组
	
	示例：
		t = tuple
		t = tuple("ABC")
		t = tuple(range(1,10,3))
	元组的运算：
		+ += * *=
		t = (1,2,3) + (4,5,6)   #  t = (1,2,3,4,5,6)
		t = (1,2,3,)
		t += (4,5,6,)          # t = (1,2,3,4,5,6)
		t = (1,2) * 2          # t = (1,2,1,2)
		t = (1,2)
		t *= 2      # t =(1,2,1,2)
	比较运算：
		< <= > >= == !=
		比较规则与列表的比较规则完全相同
	in 和 not in
		等同于列表的in 和 not in运算符
	索引和切片
		索引取值和切片取值的规则与列表完全相同
		
		注：元组不支持 索引赋值 和 切片赋值
	元组的方法	
		t.count(x)  计算元组中的x元素的个数  
		t.index(x)  计算第一个x出现的索引值
		可参见文档：
	
	序列相关的函数也能用于元组中
		len(x),max(x),min(x),sum(x),any(x),all(x)
		
	序列容器（str,list,tuple,...）
	
字典 dict
	什么是字典
		1.字典是一种可变的容器，可以储存任意类型的数据
		2.字典中的每个数据都是用“键”(key)进行索引的，而不像
		  序列（str,list,tuple）可以用整数来进行索引
		3.字典中的数据没有先后顺序关系，字典的储存是无序的
		4.字典的数据以 键(key)-值(value)对 形式进行储存
		5.字典的键不能重复，且只能用不可变类型作为字典的键
		
	创建字典的字面值方式：
		字典的表示方式以{}括起来，以:冒号分隔键值对，各键值对之间用逗号分隔开
		
	创建空字典：
		d = {}
	创建非空字典：
		d = {"姓名":"tarena","年龄":35}
		d = {"one":1,"two":2}
		d = {1:"one",2:"二",3:[1,2,3]}
		d = {"a":list(range(10))}
		d = {"a":{"b":100,"c":[1,2,3]}}
	创建字典的构造函数：
		dict()             # 生成一个空的字典 等同于{}
		dict(iterable)     # 用可迭代对象创建一个列表
		(可迭代对象只能是复合序列，且序列里面只能有两个对象)
		dict(**keargs)     # 关键字传参形式生成一个字典
		(name,age等必须是变量名的命令规则，而且生成的字典的键得是字符串)
		d = dict(name="tarena",are=15) # d = {'age':15,'name':'tarena'}
		示例：
			d = dict()
			L = [(1,2),[3,4]]
			dict(L)   #  {1:2,3:4}
			L = [(1,2),[3,4]，“AB”]
			dict(L)   #  {1:2,3:4,'A':'B'}
			d = dict(name="tarena",are=15) # d = {'age':15,'name':'tarena'}
			
	字典的键必须为不可变类型的值
		可变的类型有四种：
			list（列表），dict（字典），set（集合），bytearray（字节数组）
		（除上述四种其他为不可变类型）
		
	字典基本操作
		字典的键的索引
			语法：
				字典[键]
			作用：
				用键获取字典的键对应的值
		示例：
			d = {'name':'tarena','age':16}
			print(d['name'],"的年龄是",d['age'])
			
		添加和修改字典的元素：
			语法：
				字典[键] = 值
			说明：
				键不存在时，创建键，并让键绑定对应的值
				键存在，修改绑定的值
			示例：
				d = {}
				d['name'] = "小张"  #  添加一个键值对
				d['年龄'] = 20      #  添加一个键值对
				d['年龄'] += 1      #  修改‘年龄’这个键对应的值 此时年龄是21
练习：
	写一个程序，让用户分两次输入一个人的信息：
	信息包含：姓名 和 电话号码
	让用户输入多个人的信息，当输入姓名为空时结束输入
	把用户输入的数据存于字典中
	姓名作为键，电话号码作为值
	最后打印储存数据的字典
	如：
		请输入姓名：小张
		请输入电话：88888888888
		请输入姓名：小李
		请输入电话：66666666666
		请输入姓名：<回车>
		打印：
		{“小张”：88888888888，“小李”：66666666666}
		
		删除字典元素：
			del 语句：
				语法：
					del 字典[键]
			示例：
				d = dict(name="小张",age=20)
				del d['age']
				print(d)   #   {'name':'小张'}
		
		字典的键判断 in ，not in运算符
			可以用in运算符判断一个键是否存在于字典中，如果存在则返回True
			否则返回False
			
			not in 返回值和 in 相反
			
			例如：
				d = {'name':'tarena','age':15}
				'name' in d   #  True
				15 in d       #  False
		
练习：
	写程序，实现以下需求：
		1.将如下数据形成一个字典 seasons
			键       值
			1 -----‘春季有1,2,3月’
			2 -----‘春季有4,5,6月’
			3 -----‘春季有7,8,9月’
			4 -----‘春季有10,11,12月’
		2.让用户输入一个整数代表这个季度，打印这个季度对应的信息
		如果用户输入的信息不存在字典内，则提示用户信息不存在
		
	字典的迭代访问：
		字典是可迭代对象，字典只能对键进行迭代访问
		示例：
			d = {0:'零',5:'伍',1:'壹',2:'贰'}
			for n in d:
				print(n)   #  0,1,2,5
				
	**字典不能比较大小，也不能相加和相乘这些运算
		
	可以用于字典的函数：
		len(x)	返回字典的键值对的个数
		max(x)	返回字典的键的最大值
		min(x)	返回字典的键的最小值
		sum(x)	返回字典的所有键的和
		any(x)	真值测试，只对键进行测试，只要有一个键为真值，结果就为真值
		all(x)	真值测试，所有键的真值结果才为True
		
		示例：
			d = {0:'零',5:'伍',1:'壹',2:'贰'}
			len(x)
			d.get(6,"你要的东西不存在") # 你要的东西不存在
			
			for x in d.keys():
				print(x)  # 0,1,2,5
			for x in d,values():
				print(x)  # 零，壹，贰，伍
			for x in d,items():
				print(x)  # (0:'零'),(5:'伍'),(1:'壹'),(2:'贰')
			for k,v in d,items():
				print("键是",k,"值是",v)
	字典的方法：
		文档参见：Python_base_docs
		
练习：
	输入一段字符串，打印出这个字符串中出现过的字符及出现过的次数
	如：
		输入abcdabcaba
		打印如下：
		a：4次
		b：3次
		c：2次
		d：1次
		注：不要求打印顺序
		
	字典推导式：
		字典推导式是用可迭代对象来创建字典的表达式
		语法：
			{键表达式：值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
			注：[]的内容可以省略
		示例：
			生成一个字典：键为数字0-10，值为键的平方
			# 如{0:0,1:1,2:4,3:9,...,9:81}
			  {x:x**2 for x in range(10)}
			  print(d)
	字典推导式的嵌套：
		语法同列表推导式的嵌套
		
练习：
		已知有如下字符串的列表：
			L = ['Tarena',;XiaoZhang','xiaowang']
		生成如下字典：
			d = {'Tarena':6,'XiaoZhang':9,'xiaozhang':8}
			
		{L[x]:len(L[x]) for x in range(2)}
		方法1：
		s: len(s) for in s
		方法二：
		d = {}
		for s in L:
			d[s] = len(s)
		print(d)
		
练习：
	Nos = [1001,1002,1005,1006]
	names = ['Tom','Jerry','Spike','Tyke']
	试生成如下字典：
		d = {1001:'Tom',1002:'Jerry',1005:'Spike',1006:'Type'}
		
字典 VS 列表
	1.都是可变的容器
	2.索引方式不同，列表用整数索引，字典用键索引
	3.列表的存储是有序的，字典的存储是无序的
	4.字典的插入，删除，修改的速度可能会快于列表（重要）
	
		
练习：
	1.生成前40个斐波那契数列 （Fibonacci 数列）
		1 1 2 3 5 8 13 21...从第三个数起，后面数都是前两个数之和
	要求：将这些数存入在列表中
		最后打印出这些数
	2.有一只小猴子，摘了很多桃子
	第一天吃了全部的桃子的一半，感觉不饱又吃了一个
	第二天吃了剩下的一半，感觉不饱又吃了一个
	以此类推...
	到第10天，发现只剩下一个了
	问：第一天摘了多少桃子
	3.打印九九乘法表：
	1x1=1
	1x2=2 2x2=4
	1x3=3 2x3=6 3x3=9
	...
	.................9x9=81
	4.任意输入很多个学生的姓名，年龄，成绩（0-100），每个学生的信息
	存入到字典中，然后再放在列表内。
	每个学生的信息需要手动输入：
	如：
		请输入姓名：tarena
		请输入年龄：15
		请输入成绩：99
		请输入姓名：china
		请输入年龄：70
		请输入成绩：98
		请输入姓名：<回车> 结束输入
	内存存储格式如下：
		infos = [{'name':'tarena','age':15,'score':99},
		         {'name':'china','age':70,'score':98}]
		
	1.打印以上的列表
	2.按如下表格打印学生的信息
	+------------------+---------------+---------------+
	|      姓名        |     年龄      |      成绩     |
	+------------------+---------------+---------------+
	|      tarena      |     15       |        99      |
	|       china      |     70        |       98      |
	+------------------+---------------+---------------+