Python学习day8

元组 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"            # 序列赋值


元组的构造(创建)函数 tuple
    tuple() 生成一个空的元组,等同于()
    tuple(iterable)  用可迭代对象生成一个元组
  示例:
    t = tuple()
    t = tuple([2,3,5,7])
    t = tuple(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)  # 等同于字符串规则
    t *= 2  
  
元组的比较运算:
  > >= < <= == !=
    规则与列表的比较规则完全相同
  示例 
    (1, 2, 3) < (1, 3, 2)  # True
    (1, 2, 3) != (1, 3, 2)  # True
    ....
    (1, '二') < ('二', 1)


in / not in 运算符:
   与列表的in / not in 规则完全相同


   2 in (1, 2, 3, 4) # True
   '2' not in (1, 2, 3, 4)  # True


索引和切片
  索引:
    元组[整数]
  切片:
    元组[整数:整数]
    元组[整数:整数:整数]
  规则同字符串的切片规则
  元组不支持索引赋值和切片赋值


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


序列的种类:
  字符串str, 列表list, 元组tuple,
  字节串bytes, 字节数组bytearray(后面再讲)


能用于序列的函数总结：
  len(x), max(x), min(x), sum(x), any(x),all(x)
  str(obj)  将对象转为字符串
  list(iterable) 将可迭代对象转为列表
  tuple(iterable) .........转为元组
  reversed(seq)  返回反向顺序的可迭代对象
  sorted(iteralbe, reverse=False)

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

  字典的字面值表示方式:
    {} 括起来，以冒号(:) 分隔键-值对, 各键-值对用逗号分隔开
  创建空字典:
    d = {}  # 空字典 
  创建非空字典:
    d = {'name':'tarena', 'age': 15}
    d = {1:'星期一', 2:"星期二"}
    # 以下写法会出现问题（因为键不能重复)
    d = {'a': 1, 'b': 2, 'a': '一'}  

  字典的构造(创建)函数 dict
    dict()    # 创建空字典，等同于 {}
    dict(iterable)  用可迭代对象初始化一个字典
    dict(**kwargs)  关键字传参形式生成一个字典
  示例:
    d = dict()
    d = dict([('name', 'tarena'), ('age', 15)])
    d = dict(name='tarena', age=15)

字典的基本操作:
  字典的键索引
    用[] 运算符可以获取和修改键所对应的值
  语法:
    字典[键]
  示例:
    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  # False
    3 not in d  # True
    'One' in d  # False


字典的迭代访问:
  字典是可迭代对象，字典只能对键进行迭代访问


  示例:
    d = {1: "One", 2: "Two", "三": 'Three'}
    for k in d:
        print(k, '对应的值是:', d[k])



练习:
  写程序，实现以下要求:
    1. 将如下数据形成一个字典 seasons
        键     值
        1      '春季有1,2,3月'
        2      '夏季有4,5,6月'
        3      '秋季有7,8,9月'

        4      '冬季有10,11,12月'

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

seasons = {
    1: '春季有1,2,3月',
    2: '夏季有4,5,6月',
    3: '秋季有7,8,9月',
    4: '冬季有10,11,12月'
}

n = int(input("请输入季节(1~4): "))
if n in seasons:
    print(seasons[n])
else:
    print("信息不存在")

    2. 让用户输入一个整数代表季度,打印这个季度的信息。
       如果用户输入的信息不在字典中，则提示'信息不存在' 
可以用于字典的内建(built-in)函数
  len(x)  返回字典的键值对的个数
  max(x)  返回字典的键的最大值
  min(x)  返回字典的键的最小值
  sum(x)  返回字典的键的和
  any(x)  真值测试，如果字典中的一个键为真，则结果为真
  all(x)  真值测试，字典中所有键为真，则结果才为真


  示例:
    d = {1:'One', 2:'Two', 3:'Three'}
    for k, v in d.items():
        print("字典的键是:", k, '值是:', v)

字典推导式
  字典推导式是用可迭代的对象依次生成字典的表达式


  语法:
    { 键表达式: 值表达式 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}
  答:
    D = {x: len(x) for x in L}


练习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. 列表的存储是有序的，字典的存储是无序的


列表 和字典 的内部存储原理
  列表，顺序存储
  字典，映射存储