python基础-day08

元组　tuple
   元组是不可变的序列，同list一样，元组可以存放任意类型的数据
表示方法：
　　用小括号()括起来，单个元素括起来后加逗号（，）区分单个对象还是元组
创建空元组的字面值：
　　t=()  #空元组
创建非空元组的字面值表示：
　　t=200,＃含有一个元素的元组
　　t=(20,) #含有一个元素的元组
　　t=(1,2,3)
   t=100,200,300

type(x)返回对象的类型

创建元组的错误示例：
　　t=(20)  # t绑定整数２０
　　x,y,z=100,200,300 #序列赋值，不是元组
　　x,y,z=[100,200,300]
   x,y,z="ABC"

元组的构造函数：
　　tuple() 创建空元素，等同于()
   tuple(iterable)  用可迭代对象生成一个元组
   示例：
   　　t=tuple() #空元组
   　　t=tuple(range(1,10,3))
      t=tuple('ABC')
      t=tuple([1,2,3])
元组的运算：
　　+ += * *= <  <=  >  >=  ==  != 
    in /not in
    索引／切片
示例：
　　t=(1,'二','three')+(4.5,True,None) #  (1,'二','three',4.5,True,None)
　　比较运算：
　　　规则等同于列表的比较规则
　　　(1,3,2)>(1,2,3)  ＃True 
     1,2,3>1,2       # (1,2,True,2)     大于优先级大于逗号
     (1,2,3)>(1,2)   #True
     (1,'二')>('二',１)　＃TypeError

     in /not in 运算符
     　　同列表的in 运算符相同，用于检查一个值是否存在元组中，如果存在返回True,否则返回False
        not in 与in 返回值相反
        如：
        　2 in (1,2,3) #True
        100 in (1,2,3) #False


    索引和切片的操作：
    　　用法等同于列表的操作
    　　元组不支持索引和切片的赋值操作
    如：
    　t=(1,2,3,4)
     print(t[3])  #4

用于元组的函数：
　　len(x)/max(x)/mim(x)/sum(x)/any(x)/all(x)

构造函数：
　　str([obj])
   list([iterable])
   tuple([iterable])

反转函数：
　　reversed(iterable)  返回反向顺序的可迭代对象
　　　如：
　　　　for x in reversed('ABC')
          print(x)    #打印 C B A

字典 dict
什么是字典
　　１字典是一种可变的容器，可以存储任意类型的数据
　　２字典中的每个数据都是用键（key）进行索引，而不像序列
　　　　（字符串，元素，列表）可以用索引下标进行索引
　　３字典中的数据没有先后关系，字典的存储是无序的
　　４字典的数据以键(key)-值(value)对形式进行映射存储
　　５字典的键不能重复，且只能用不可变类型作为字典的键

　　字典的表示方式是以｛｝括起来，以冒号（：）分割键值对，各
　　　键值对之间用逗号分隔开

创建空字典的字面值
　d={}   #空字典
创建非空字典字面值
 d={'name':'tarena','age':15}
 d={100:'一百'}
 d={'a':tuple('abc')}  #值为元组
 d={True:'真值'}
 d={(1970,1,1):'计算机元年'}

 　字典的值可以是任意类型
 　字典的键只能是不可变类型
 　　　不可变类型：
 　　　　bool , int float complex str tuple  frozenset(固定集合)
 　　　　bytes(字节串)
 　　　可变类型：
 　　　　list  dict set  bytearray(字节数组)

 字典的构造函数　dict
   dict()   生成一个空字典　等同于{}
   dict(iterable)  用可迭代对象初始化一个字典
   dict(**kwargs)  用关键字传参形式生成一个字典
   示例：
   　　d=dict()
      d=dict([('name','tarena'),('age',15)])  #可迭代对象提供的数据必须是有两个元素的序列
      d=dict(name='tarena',age=15)


字典的基本操作：
　　字典的键索引
　　　　语法：
　　　　　　字典[键]
　　　　作用：
　　　　　　用[]运算符进行取值操作
　　　　示例：
　　　　　　d={'name':'tarena','age':16}
          print(d['name'],'今年',d['age','岁'])
添加和修改字典元素：
　　语法：
　　　　字典[键]＝值
　　说明：
　　　　键不存在，创建键并绑定键对应的值
　　　　键存在，修改键绑定的值
　　示例：
　　d={}
   d['name']='tarena'  #创建新键值对
   d['age']=15   #创建新键值对
   d['age']=16    #修改age键绑定的值

练习：
　　创建一个字典：
　　d={'name':'tarena','age':15}
    为此字典添加地址(address)键,对应的值为'北京市海淀区'，结果如下

d={'name':'tarena','age':15}
d['address']='北京市海淀区'
print(d)

#d={'name':'tarena','age':15,'address':'北京市海淀区'}

删除字典键值对：
　　del 语句
　　语法：
　　　del 字典[键]
　　示例：
　　　d={'name':'tarena','age':15}
      del d['name']   #删除键　'name'

字典的in /not in运算符
　　1可以用in 运算符来判断一个键是否存在于字典中，如果存在则返回True,否则返回False
   2 not in／与in 返回值相反
   示例：
   d={'a':100,200:'二百'}
　　'a' in d #返回True
    200 in d #True
    100　in d # False
    100 not in d # True 

练习：
　1将如下数据形成一个字典seasons:
    键　　　　　　值
    １　　－－－> '春季有１，２，３月'
    ２　－－－　> '夏季有４，５，６月'
    ３　　－－－> '秋季有７，８，９月'
    ４　　－－－> '冬季有１０，１１，１２月'

２让用户输入一个整数，代表季度，打印这个季度的信息，如果用户输入的信息不存在字典内，
　　则打印'信息不存在'
seasons={}
seasons[1]='春季有1,2,3月'
seasons[2]='夏季有4,5,6月'
seasons[3]='秋季有7,8,9月'
seasons[4]='冬季有10,11,12月'
a=int(input('输入一个整数'))
if a in seasons:
    print(seasons[a])
else:
    print('信息不存在！')

字典的迭代访问：
　　字典是可迭代对象，字典只能对键进行迭代访问
示例：
　　d={'name':'tarena',(2012,1,1):'生日'}
　　　for k in d : #k用来绑定字典的键
　　　　print(k,'对应的值是：',d[k])

可以用于字典的内建函数
　 len(x)   返回字典键值的个数
　 max(x)   返回字典键的最大值
　 min(x)   返回字典键的最小值
　 sum(x)   返回字典中所有键的和
　 any(x)   真值测试，如果字典中其中一个键为真值则返回True
   all(x)   真值测试，如果字典中全部键为真值则返回True

示例：
　　d={0:'零',5:'伍',8:'捌'，３：'叁'}
　　 len(d)   #4
    max(d)   #8
    min(d)   #0
    sum(d)   #16
    any(d)   True
    all(d)   False

字典的方法
文档参见_html/dict_html
d={0:'零',5:'伍',8:'捌',３:'叁'}
for k,v in d.items():
    print(k,'的值是',v)
0 的值是 零
8 的值是 捌
3 的值是 叁
5 的值是 伍

练习：
输入一个字符串，打印这个字符串中出现的字符以及出现的次数
如: ABCDABCDABA
打印：（不要求先后顺序）
　　a:4次
　　b:3次
　　c:2次
　　d:1次
a=input('输入字符串')
d={}
for x in a:
    d[x]=a.count(x)
print(d)

字典的推导式：
    字典推导式是用可迭代对象依次生成字典内元素的表达式
    语法：
        ｛键表达式：值表达式　for 变量　in 可迭代对象　[if 真值表达式]｝
        注：[]的内容代表可以省略
    示例：
        ＃生成一个字典，键数为１～９，值为键的平方
        d={x: x**2 for x in range(1,10)}
        #{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

        有如下字符串：
        L=['tarena','xiaozhang','hello'] 生成键为单词，值为单词长度的字典
        d={s:len(s) for s in L}
        print(d)
    字典vs列表
    １.都是可变的容器
    ２．索引方式不同，列表用整数索引，字典用键索引
    ３．字典的删除。插入，修改速度可能快于列表（重要）
    ４．列表的存储是有序的，字典的存储是无序的

练习：1已知有两个等长的列表
        list1=[1001,1002,1003,1004]
        list2=['Tom','Jerry','Spike','Tyke']
        写程序生成如下字典：
        {'Tom:1001','Jerry':1002,
        'Spike',1003,'Tyke':1004}
    2任意输入多个学生的姓名，年龄，成绩，每个学生信息存入一个字典中，然后再放入列表中
    　（学生信息手动输入）
    　如：
        请输入姓名：tarena
        请输入年龄：15
        请输入成绩：99
        请输入姓名：name2
        请输入年龄：23
        请输入成绩：98
        回车结束输入
    在程序内生成如下列表：
    L=[{'name':tarena,'age':15,'score':99},{'name':name2,'age':22,..}]
    (1)打印上述列表
    (2)以下列表的形式打印出上述信息
    ＋－－－－＋－－－－－＋－－－－－－＋
    |name    ｜　age　 ｜　score    |
    ＋－－－－ ＋－－－－－＋－------－＋
    |　tarena｜     15 |     99    |
    |　name2 ｜　　　22 |　　　95    |
    + --------+-------＋-----------＋