python3基础07

day07

元组　tuple
  元组是不可改变的序列，同list一样，元组可以存放任意类型的元素
  元组一旦创建将不可改变（同字符串相似）

元组的表示方式：
　　用小括号（）括起来，单个元素括起来后加逗号（，）
　　区分单个对象还是元组

创建空元组的字面值表达式：
　　　t=()      #()是创建一个空的元组对象

创建非空元组的自面值表达式：
　　t = 200,
  t = (20,)
  t = (1,2,3)　　　　　　　　　#含有3个元素的元组
  t = 100,200,300　　　　　#含有3个元素的元组

  注：type(x)函数，可以返回对象x的类型
  t　=　200
  type(t)             #int
  type(t) is int      #True 

  ''空字符串
  []空列表
  ()空元组

元组错误示例：
　  t = (200)                # t绑定20这个对象，不是元组
　　　x, y, z = 100, 200, 300  #序列赋值
   x, y, z = (100, 200, 300)#序列赋值
　　　x, y, z = [100, 200, 300]#序列赋值
   x, y, z = "ABC"          #序列赋值

元组的构造函数tuple
　　　tuple()   生成一个空元组，等同于（）
　　　tuple(iterable)  用可迭代对象生成一个元组
　　示例：
　　　　t = tuple()
    t = tuple("ABC")
    t = tuple(range(1,10,2))

元组的运算
　　　+　用于拼接方式创建一个新的元组    元组与元组相加
　　　*　用于生成新的重复的元组　　　　　乘以整数
  示例：
　　　t = (1, 2, 3)+(4, 5, 6)    #t = (1,2,3,4,5,6)
   t += (7, 8, 9)             #t = (1,2,3,4,5,6,7,8,9)

   t = (1,2)*3                #t = (1,2,1,2,1,2)
   t *=4                      #t = (1,2,1,2,1,2,1,2)

元组的比较运算：
　　　<  <=  >  >=  ==  !=    规则与列表的比较规则完全相同

元组的in/not in 运算符
　　用于判断元素是否存在于元组中，规则与列表完全相同

索引　　index
　　用法等同于列表的索引
　　元组不支持索引赋值

切片
　　用法与列表的切片用法相同
　　元组的切片返回一个新的元组
　　元组不能切片赋值

元组的方法　
　　　T.index(v [, begin[, end]]) 
   返回对应元素的索引下标,begin为开始索引，end为结束索引
   当v不存在时触发ValueError错误
   T.count()  
   返回元组对应的元素个数

序列小结：
　　　字符串　str   (一旦创建不可改变，只能存放字符)
　　　列表　　list　　(可变的)
　　　元组　　tuple　　(一旦创建不可改变，能够存放各种类型)
--------------------------------
　　　字节串　bytes
   字节数组　　bytearray

序列相关的函数：
　　len(x),max(x),min(x),sum(x),any(x),all(x)
  
  示例：
  any('hello')        #True
  all("hello")        #True

  reversed(x)   返回反向顺序的可迭代对象
  示例：
  　s = 'ABC'
   for ch in s:
       print(ch)  #A B C
   
   s = 'ABC'
   for ch in s[::-1]:
       print(ch)  #C B A

   s = 'ABC'
   for ch in reversed(s):
       print(ch)  #C B A

   L = list(reversed(s))  #['C','B','A']

   L = [1,3,7,9]
   L2 = [x**2 for x in reversed(L)]
    # [81,49,9,1]

字典　dict
　　什么是字典：
　　　　1.字典是一种可变的容器，可以存储任意类型的数据
　　　　2.字典中的每个数据都是用"键"（key）
　　　　  进行索引的，而不像序列可以用索引下标进行索引
　　　　3.字典中的数据没有先后顺序的关系，字典的存储是无序的
　　　　4.字典中的数据以键-值对（key-value）对形式进行映射存储
      (以成对形式出现，映射是指变量的绑定关系)
　　　　5.字典的键不能重复，且只能用不可变类型作为字典的键
　　　　　　（键不能放列表，因为列表是可变的，
　　　　　　　　字典也不能作为字典的键）

　　字典的字面值表示方法：
　　　　以{}括起来，以冒号（：）分隔键-值对，各键值对用逗号分隔开

　　创建空字典：
　　　　d = {}      #{}表达式用来创建一个空的字典

　　创建非空字典：
　　　　d = {'name':'xiaoming','age':35}
    d = {'a':100}
    d = {'a':tuple("ABC")}
    d = {'abc':list("ABC")}
    d = {'a':{'b':100,'c':200}}
    f = {True:'真值',Flase:'假值',None:'空',100:'一百'}
    d = {(1970,1,1):'计算机元年'}

字典的构造函数：dict
　　dict()     创建一个空字典，等同于{}
　　dict(iterable)  用可迭代对象创建一个新的字典
　　dict(**kwargs)  用关键字传参形式创建一个新的字典

示例：
　　d = dict()
  d = dict((['name','tarena']),('age',15))
  d = dict((['name','xiaoming'],'ABC')) 
  d = dict(name='tarena',age=15)   

字典的索引操作
　　字典的键索引
　　　用[]运算符可以获取字典内'键'对应的'值'
　　语法：
　　　　v = 字典[键]
　　示例：
　　　　d = {'name':'tarena','age':15}
    print(d['name'],'今年',d['age'],'岁')

添加和修改字典的元素
　　语法：
　　　字典[键] = 表达式
　　示例：
　　　　d = {}
    d['name'] = 'tarena'  #创建新的键'name'同时关联值
    　　　　　　　　　　　　　　　　　　　　　　　d = {'name':'tarena'}
    d['age'] = 15         #创建并绑定15
                        d = {'name':'tarena','age':15}
    d['age'] = 16         #修改原来的键'age',重新绑定为16
　　说明：
　　　　键不存在，创建键，并绑定值
　　　　键存在，修改键的绑定关系

删除字典元素　del语句
　　del  字典[键]
　　示例：
　　　　d = {1:'_','hello':world,True:'真值'}
　　　　del d['hello']
    #True 和１　不能同事存在，True就是１
    
    d = {1:'_','hello':world,False:'假值'}
　　　　del d['hello']
　　　　# d = {1:'_',False:'假值'}

字典的in　/not in 运算符
　　　用in和not　in 用来判断一个键是否存在字典中，
   如果存在返回True,否则返回False
   not in 的返回结果与　in 相反

示例：
　　　d = {'name':'小张','age':20}
   'name' in d    #True
   'age' not in d   #False
   '小张'　in d      #False (只判断键，不判断值)
    20 not in d     #True

练习：
　　写程序，实现以下要求：
　　　1.将如下数据形成一个字典seasons
     键　　　　　　　　　　　值
     1          '春季有1,2,3月'
     2　　　　　　　　　 '夏季有4,5,6月'
     3　　　　　　　　　　'秋季有7,8,9月'
     4　　　　　　　　　　'冬季有10,11,12月'
   2.让用户输入一个整数代表这个季度，打印这个季度有信息
   　　如果用户输入的信息不在字典中，则打印＂信息不存在＂

字典的迭代访问
  所有的容器都是可迭代对象，都可以绑定for语句
　　字典是可迭代对象，字典只能对"键"进行访问
　　示例：
　　　d = {'aaa':111,'bbb':222,'ccc':333}
   for k in d:
       print(k)

    #aaa
     bbb
     ccc

   d = {'aaa':111,'bbb':222,'ccc':333}
   for k in d:
       print("键",k,"对应的值是",d[k])

    #键　aaa　对应的值是　111
     键　bbb　对应的值是　222
     键　ccc　对应的值是　333

　　可以用于字典的函数：
　　　len(x)   返回字典的键值对个数
　　　max(x)   返回字典键的最大值
　　　min(x)   返回字典键的最小值
　　　sum(x)   返回字典所有键的和
　　　any(x)   真值测试，只对键进行测试
　　　all(x)   真值测试，全部键为真值，结果才为True
  
  示例：
  　 d = {0:'零',5:'伍',8:'捌',3:'叄'}
  　　len(d)    # 4
    max(d)    # 8
    min(d)    # 0
    sum(d)    # 16
    any(d)    # True
    all(d)    # False

字典的方法：
　　　方法名　　　　　　　说明
　　D.clear()   清空字典
　　D.pop(key)  移除键，同时返回此键对应的值
　　D.copy()    返回字典D的副本，（浅拷贝）
　　D.update(D2)将字典D2合并到D中，
              如果键相同，
              则此键的值取D2的值为新值
  D.get(key,default)返回key所对应的值，
                    如果没有此键，
                     则返回Default
  D.keys()    返回可迭代对象dict_keys集合对象
  D.values()  返回可迭代对象dict_values集合对象
  D.items()   返回可迭代对象的dict_item对象

  示例：
  　d = {1:'one',2:'two'}
   d2 = {2:'二',3:'三'}
   d3 = d.copy     #复制
   d3.pop(1)       #d3={2:'two'} 
   d.update(d2)    # d = {1:'one',2:'二',3:'三'}
   for k in d.keys():
       print(k)    #  1 2 3
   for v in d.values():
       print(v)    # 'one'  '二'  '三'
   for t in d.items():
       print(t)    # (1:'one') (2:'二') (3:'三')
   for k,v in d.items():
       print("键",k,"对应的值是",v)

    # 键　1　对应的值是　one
      键　2　对应的值是　二
      键　3　对应的值是　三

　练习二：
　　输入任意一段字符串，打印出这个字符串中出现过的字符
　　　及出现过的次数

　　如：
　　　输入：ABCDABCABA
　　打印入下：
　　　A : 4次
   B : 3次
   C : 2次
   D : 1次
   不要求打印的顺序

字典推导式
　　是用可迭代对象生成字典的表达式
  (列表和字典不能作为字典的键，字典的键不能重复)
　　
　　语法：
　　　{键表达式：值表达式　for 变量　in 可迭代对象[if 　　　　真值表达式]}

　　注：[]表示其中的内容可以省略

　　示例：
　　　　生成一个字典，键为数字1~9,值为键的平方
　　　　d = {i**2 for i in range(1,10)}

zip函数(以最短的标准)
　生成字典/元组/列表
    示例：
    L = ['tarena','xiaoming','abc']
　　　　d = [８，６，３]

　　　　print(dict(zip(L,d)))
　　　＃{'xiaoming': 8, 'tarena': 6, 'abc': 3}

练习三：
　　1.已知有如下字符串列表
　　　 L = ['tarena','xiaoming','abc']
    生成如下字典：
   　d = {'tarena':6,'xiaoming':9,'abc':3}
    注：字典的值为键的长度

  2.已知有入下两个列表：
  　　nos = [1001,1002,1005,1008]
    names=['Tom','Jerry','Spike','Tyke']
    用上述两个列表生成如下字典：
    {1001:'Tom',1002:'Jerry',1005:'Spike',1008:'Tyke'}

字典推导式的嵌套等同于列表推导式的嵌套

字典和列表的比较
１．都是可变对象
２．索引方式不同，列表是用整数索引，字典是用键索引
３．字典的插入，删除，修改的速度可能会快于列表（重要）
４．列表的存储是有序的，字典的存储是无序的
示例：
　L = [9,4,10043,4,29,234,23,2........,123]
  1006  in  L   #列表为顺序存储

课后练习:
  1. 写一个程序模拟现实电子字典
     1) 输入一些单词和解释,将单词作为键,将解释作用值,将这些数据输入到字典中,当输入空单词时结束输入
     2) 输入要查找的词,给出该单词的解释.如果单词不存在则提示用户不存在该单词
  
  2. 学生信息管理项目
    输入任意个学生的姓名,年龄,成绩.每个学生的信息存入一个字典内,然后放入到列表中
       (每个学生需要手动输入)
    如:
      请输入姓名: tarena
      请输入年龄: 20
      请输入成绩: 99
      请输入姓名: name2
      请输入年龄: 30
      请输入成绩: 88
      请输入姓名: <回车> 结束输入
    形成内部存储格式如下:
      [{'name':'tarena', 'age':20, 'score':99}, {'name':name2, 'age':30, 'score':88}]
    1) 打印出存有学生信息的字典的列表
    2) 按表格形式打印出学生信息:
      +---------------+----------+----------+
      |     name      |   age    |   score  |
      +---------------+----------+----------+
      |    tarena     |    20    |     99   |
      |     name2     |    30    |     88   |
　　　　　　+---------------+----------+----------+