Python学习笔记day08,元组，字典方法和推导式

元组 (tuple)

元组是不可改变的序列，同list一样，元组可以存放任意类型的元素
元组一但创建将不可改变

• 元组的表示方式:

  用小括号() 括起来，单个元素括起来后加逗号(,)区分单个对象还是元组

• 创建空元组的字面值表达式:

  t = ()  # () 是创建一个空的元组对象

• 创建非空元组的字面值表达式:

  t = 200,
  t = (20,)
  t = (1, 2, 3)
  t = 100, 200, 300

  注:
type(x)函数 可以返回对象x的类型

• 元组错误示例:

  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,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2)

• 元组的比较运算：

  例：< , > , <= , >= , == , !=
  规则和列表的比较规则一模一样

• 元组的in / not in 运算符：

  1. 用于判断元素是否存在于元组中，规则和列表的规则一模一样

• 索引(index):

  1. 用于判断元素是否存在于元组中，规则和列表的规则一模一样
  2. 元组不支持索引赋值

• 切片：

  1. 用法和列表的切片用法相同
  2. 元组的切片返回一个新的元组对象
  3. 元组不能切片赋值

• 元组的方法:

  方法	说明
  T.index(v[,begin[,end]])	返回对应元素的索引下标，begin为起始索引，end为结束索引
  T.count(x)	返回元组中X元素的个数

---

---

字典(dict)：

• 什么是字典：

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

• 字典的创建方法：

  1. 创建空字典:
     d = {}

  2. 创建非空字典

     d = { 'a' : 'b' }
     d = {'name' : 'gaoxiangyang','age' : '20'}
     d = {'a' : tuple("abc")}
     d = {'a' : list("abc")}
     d = {'a' : { {'b' : 'c' } } }
     d = {True:'真值', False: '假值', None:'空', 100:'一百'}
     d = {(1970, 1, 1): '计算机元年'}

  3. 字典的 in / not in 运算符：

     in 用来判断字典里是否包含有某一个键元素

  4. 字典的构造函数 dict

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

     示例:

     d = dict()
     d = dict([('name', 'tarena'), ('age', 15)])
     d = dict((['name', 'weimingze'], "AB"))
     d = dict(name='Tarena', age=15)

• 字典的操作:

  • 字典的键索引
    用 [ ] 运算符可以获取字典内’键’对应的’值’
    v = 字典[键]
  • 示例:
    

    d = {'name': 'tarena', 'age': 15}
    print(d['name'], '今年', d['age'], '岁')

• 添加/修改字典的元素:

  • 语法:

    字典[键] = 表达式

  • 示例:

    d = {}
    d['name'] = 'tarena'  #创建新的键'name'同时关联值
    d['age'] = 15  # 创建键并绑定15
    d['age'] = 16  # 修改原来的键'age',重新绑定为16

  • 说明:
    键不存在,创建键,并绑定值
    键存在,修改键的绑定关系

• 删除字典元素 del语句

  • 语法：

    del 字典[键]

  • 示例:
    

    d = {1:'一', 'hello': 'world', False:'假值'}
    del d['hello']

• 可用于字典的函数

  函数	说明	例子
  len(x)	返回字典的键值对个数
  max(x)	返回字典键的最大值
  min(x)	返回字典键的最小值
  sun(x)	返回字典中所有键的和
  any(x)	真值测试，只对键进行测试
  all(x)	真值测试，全部键为真值，结果才为True
  str(dict)	生成字典的可打印字符串表示形式

• 字典的方法

  方法名	说明	例子
  D.clear()	清空字典
  D.pop(key)	移除键，同时返回此键的对应的值
  D.update(D2)	将字典D2合并到D中，如果有键相同，则D2覆盖D为新值
  D.copy()	返回字典D的副本，浅拷贝
  D.get(key,default)	返回key所对应的值，如果没有此键，则返回Default的值
  D.keys()	返回可迭代的dict_keys键值对象
  D.values()	返回可迭代的dict_values值对象
  D.fromkeys()	创建一个新的字典，其中包含seq的值和设置为value的值。
  D.setdefault(key, default = None)	类似于get()，如果key不在字典dict中，则将执行赋值操作：dict [key] = default
  D,items()	返回可迭代的dict_items 元组对象

• 练习：

  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月" 
              }
  
  ###########################################                 
  
  a = int(input("输入"))
  l=seasons[a] if a in seasons else "不存在"   
  print(l)

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

  • 语法：
    { 键表达式 ：值表达式 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}
    

  • 推导式练习：

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

    L=['tarena', 'xiaozhang', 'abc']
    print({i : len(i) for i in L })
    
    # {'tarena': 6, 'xiaozhang': 9, 'abc': 3}
    

    1. 已知有如下的两个列表：
       nos = [100, 1002 ,1005, 1008]
       names = [‘Tom’, ‘Jerry’, ‘Spike’, ‘Tyke’ ]
       生成字典:
       {100 : ‘Tom’ , 1002 : ‘Jerry’ ,1005 : ‘Spike’, 1008 : ‘Tyke’ }

    names = ['Tom', 'Jerry', 'Spike', 'Tyke' ]
    print({ x : y for x in nos for y in names })
    
    # {100: 'Tyke', 1002: 'Tyke', 1005: 'Tyke', 1008: 'Tyke'}
    

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

• 字典 VS 列表

  1. 都是可变对象
  2. 索引方式不同：列表用整数下标索引，字典用键索引
  3. 字典的插入、删除、修改的速度可能会快于列表（重要）
  4. 列表的存储是有序的，字典的存储是无序的