day07笔记：
今天内容
元组 tupie
字典 dict
1、元组 tuple
元组的定义：
元组是不可改变的序列，同list一样，元组是可以存放任意类型的容器
元组的表示方法：
用小括号（）括起来，单个元素括起来后加逗号（，）区分单个对象还是元组
创建空元组的字面值
t = （） # t绑定空元组
创建非空元组
t = 200，
t = （20，）
t = （1,2,3）
t = 100,200,300
type （x） 函数用来返回 x 的类型
元组的错误示例：
t = （20） # t 绑定定整数， 不是元组
x， y，z = 100,200,300 # 序列赋值等同于如下
x，y，z = （100,200,300） # 序列赋值
x，y，z = [100,200,300] # 序列赋值
x，y，z = "ABC"# 序列赋值 # 序列赋值
元组的构造函数(创建） 函数 tupie
tupie （） 生成一个空的元组，等同于（）
tupie （iterable） 用可迭代对象生成一个元组
示例：
t = tupie （）
t = tupie （[2,3,5,7]）
t = tupie(range(10))
元组的运算：
+ 加号用于元组的拼接操作
* 乘号 用于原元组生成重复的元组
示例;
t = (1,2,3)+ (4,5,6) # t = (1,2,3,4,5,6)
t = (1,2) * 3 #t = (1,2,1,2,1,2)
t = (1,2,3)
t += (4,5,6) # 等同于字符串规则
元组的比较运算：
> >= < <= == !=
规则与列表的比较规则完全相同
示例：
(1,2,3）< (1,3,2) # Ture
(1,2,3）！= (1,3,2) # Ture
序列和元组的区别就是一个可变，一个不可变。
in / not in 运算符：
与列表的in/ not in 规则完全相同
2 not in (1,2,3,4) # Ture
索引和切片
索引：
元组 [整数]
切片：
元组[整数： 整数 ]
元组[ 整数: 整数： 整数]
规则同字符串的切片规则
元组不支持索引赋值和切片赋值
练习：
生成一个1 ~9的平方的元组，元组如下：
（1,4,9,16，.....，81）
解：#t = ()
#for i in range(1,10):
# v = i ** 2
# t += (v,)
#print(t)
方法2
#l = [x ** 2 for x in range(1,10)]
#t = (l)
#print(t)
元组的方法：
T.index（v[，begin[ ， end]]） 返回对应元素的索引下标，begin为开始索引，end 为结束索引，v不存在时触发ValueErorr错误
T.count（x） 返回元组中对应元素的个数
2、序列的种类：
字符串str， 列表list，元组tupie，
字符串bytes，字节数组bytearray（后面再讲）
能用于序列的函数总结：
len（x）， max（x），min（x），sum（x），any（x），all（x） str （obj） 将对象转为字符串
list（iterable）将可迭代对象转为列表
tuple（iterable）........................转为元组
received（seq） 返回反向顺序的可迭代对象
sorted （iterable，reverse = False）
二、字典 dict
什么是字典？
1.字典是一种可变的容器，可以存储任意类型的数据
2.字典中的每个据都是用“key”进行索引，而不像序列可以用下标开进行索引，
3.字典中的数据没有先后顺序关系，字典的存储是无序的
4.字典中的数据以键（tey）-值（value）对形式进行映射存储
5.字典的键不能重复，且只能用不可变类型作为字典的键
字典的字面值表示方式：
{ } 括起来， 以冒号（：） 分隔键- 值对，各键-值对用逗号分隔开
创建空字典：
d = { } #空字典
创建非空字典：
d = {‘name’: 'tarena','age': 15}
d = {1: '星期一'，2 ：“星期二"}
# 一下写法会出现问题，（因为键不能重复）
d = {'b' : 2 , 'b' : 2, 'a': '_'}
字典构造（创建）函数dict
dict （） #创建空字典，等同于{}
dict （iterable） 用于迭代对象初始化一个字典
dict （**kwarge） 关键字传参形式生成一个字典
示例：
d = dict （）
d = dict [(‘name’，‘tarena’)，('age', 15)]
d = dict （name = 'tarena' , age = 15）
2、字典的基本操作：
字典的键索引
用[ ] 运算符可以获取和修改啊键所对应的值
语法：
字典[ 键 ]
示例：
d = {‘name’：‘tarena ’，‘age’： 15}
print （‘姓名：’，d [‘name’]，‘年龄：’，d[‘age’]）
添加/修改字典的元素
字典[ 键] = 值
示例：
d = { }
d [‘name’] = ‘tarena’
键索引赋值说明：
当键不存在时， 创建键并绑定键对应的值
当键存在时，修改键绑定的对象
删除字典的元素
del 语句 可以用啦删除字典的键
语法：
del 字典[键]
示例：
d = {1:‘’星期一‘’，2：‘星期二’}
del d[2]
in 运算符（成员资格判断运算符）
1，可以用in 运算符来判断一个键是否存在字典中，如果存在则返回True，否则返回False
2，not in 与 in 相反
示例：
d = {1：“One”，2：“Two”,"三”：‘Three’}
1 in d # True
‘二’ in d # Talse
3 not in d # Ture
'One' in d #False
字典的迭代访问:
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {1：“One”，2：“Two”,"三”：‘Three’}
for k in d：
print（k，‘对应的值是：’）
练习：
写程序，实现以下要求：
1， 将如下数据形成一个字典 aeasons
键 值
1 ‘春季有1，2，3月’
2 ‘春季有4,5,6,月’
3 ‘春季有7，8，9月’
4 ‘春季有10,11,12月’
2，让用户输入一个整数代表季度，打印这个季度的信息。如果用户输入的信息不在字典中，则提示“信息不存在”
#d = {1: "春季有1,2,3月",
# 2: "夏季有4,5,6月",
# 3: "秋季有7,8,9月",
# 4: "冬季有10,11,12月"}
#a =int(input('输入一个整数代表季度'))
#if a in d:
# print(d[a])
#else:
# print('信息不存在')
可以用于字典的内建（built-in）函数
len（x） 返回字典的键值对的个数
max（x） 返回字典的键值对的最大数
min（x） 返回字典的键值对的最小数
sum（x） 返回字典的键的和
any（x） 真值测试，如果字典中的 一个键为真，则如果为真
all（x） 真值测试，如果字典中的所有键为真，则如果为真
字典的方法：
见python学习笔记，函数字符串
示例：
d = {1:'one', 2:'two', 3:'three' }
for k, v in d ,items( ):
print('字典的键是:",k, '值是:',v)
(1, 'one')
(2,'two')
(3,'three')
练习：
输入一段字符串，打印出这个字符串中出现过的字符及字符出现的次数
如：
输入： abcdabcabdc
输出：
a： 4次
b ： 3次
d ： 1次
c ： 2次
（不要求打印的顺序）
#f方法２
#s = input('请输入字符串:')
#d = {}
#for ch in s:
# if ch not in d:
# d[ch] = 1
# else:
# d [ch] += 1
#for ch in d:
# print(ch , ':',d[ch],'次')
字典推导式
字典推导式是用可迭代的对象依次生成字典的表达式
语法：
{键表达式：值表达式 for 变量 in 可迭代对象[if 真值表达式 ]}
注：[ ]及其中的内容代表可省略
说明：
1.先从可迭代对象中取值
2.用变量绑定
3.用if 进行条件判断，如果为真值则执行下下一步
4.执行‘键表达式’和‘值表达式’然后加入到新的字典中
示例：
生成一个字典，键为1~9的整数， 值为键的平方
d = {x:x**2 for x in range （1,10）}
练习：
有如下字符串：
l = ['tarena', 'china', 'beijing' ]
生成如下字典：
D = {‘tarena’：6，'china'：5, 'beijing'：7}
答案
#L = ['tarena','china','beijing']
#D = {x: len(x) for x in L}
#print(D)
练习2：
No = [1001,1002,1005,1008]
names = [ 'Tom', 'Jerry', 'Spike', 'Tyke' ]
用上面No列表中的数据作为键，用names中的数据作为值，生成相应的字典:
如:
d = {1001: 'Tom', 1002: 'Jerry', ....}
方法1:
d = {No[i]: names[i] for i in range(len(No))}
方法2:
d = {n: names[No.index(n)] for n in No}
字典推导式可以嵌套，语法同列表推导式
字典 vs 列表
1. 都是可变对象
2. 索引方式不同,列表用整数索引，字典用键索引
3. 字典的查找速度可能会快于列表(重要)
4. 列表的存储是有序的，字典的存储是无序的
列表 和字典 的内部存储原理
列表，顺序存储
字典，映射存储
练习：
1.输入一些单词和解释，将单词作为键，将解释作为值，将这些数据输入到字典中，当输入空的单词时结束输入，然后，输入查询的单词，给出单词对应的解释
2.（重要）！
输入任意个学生的信息：
学生信息 有：
姓名（字符串str）
年龄（整数int）
成绩（整数int）
当输入学生姓名为空时结束输入
1）将每个学生的信息形成字典，存于列表中：
如：
[{ 'name': 'xiaoqi', 'age' : 20 , 'score': 98},
{ 'name': 'xiaoyuan', 'age' : 20 , 'score': 95},]
2)以表格的形式打印所有学生的信息，如下：
+---------------+----------+----------+
| name | ag | score |
+---------------+----------+----------+
| | | |
| | | |
| ...... | ... | |
+---------------+----------+----------+
答案
#1
# dictionary = {} # 创建字典，准备保存数据
# while True:
# word = input("请输入单词: ")
# if not word: # 如果单词为空，则退出
# break
# trans = input("请输入解释: ")
# dictionary[word] = trans
# print("字典内容是：", dictionary)
# while True:
# w = input("请输入要查询的单词: ")
# if w in dictionary:
# print("解释是: ", dictionary[w])
# else:
# print("末找到解释!")
#2
while True:
# n = input("请输入学生姓名: ")
# if not n: # 如果学生姓名为空则结束输入
# break
# a = int(input("请输入学生年龄: "))
# s = int(input("请输入学生成绩: "))
# # 把上述n, a, s 所表示的信息形成字典，并加入到列表
# d = {} # 创建一个新字典，准备存入学生信息数据
# d['name'] = n
# d['age'] = a
# d['score'] = s
# L.append(d) # 把字典存入列表中
# print(L)
# # 第二步，显示所有学生的信息
# print("+---------------+----------+----------+")
# print("| name | age | score |")
# print("+---------------+----------+----------+")
# # 此处打印所有学生的信息
# for d in L: # 把每个学生的数据取出来，用d绑定对应的字典
# center_name = d['name'].center(15)
# str_age = str(d['age']) # 先将年龄转为字符串
# center_age = str_age.center(10) # 生成居中的字符串
# center_score = str(d['score']).center(10)
# line = "|%s|%s|%s|" % (center_name,
# center_age,
# center_score)
# print(line)
# print("+---------------+----------+----------+")