(D08)Python-元组,字典

元组 tuple

• 元组是不可变的序列,同list一样,元组是可以存储任意类型
  的数据的容器

元组的表式方法:

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

创建空元组的字面值:
-t = () # 创建一个空元组用t绑定

创建非空元组的字面值

  t = 200,     # 创建一个只有一个数字200的元组用绑定
  t = (20,)
  t = (1, 2, 3)
  t = 100, 200, 300

创建的元组的错误示例:

  t = (20)  t绑定整数20,不是元组
  x, y, z = (100, 200, 300)  # 序列赋值
  x, y, z = 100, 200, 300
  x, y, z = [100, 200, 300]
  x, y, z = "ABC"   # 序列赋值,不是元组
  x, y = y, x  # 交换两个变量的绑定关系

type(x) 函数返回x的类型

元组的构造函数 tuple

• tuple() 生成一个空的元组,等同于()
• tuple(iterable) 用可迭代对象生成一个新的元组

示例:

t = tuple()
t = tuple("ABC")
t = tuple(range(1, 10, 3))  

元组的运算:

     +    +=  *  *= 
  t = (1, 2, 3) + (4, 5, 6)  # t=(1,2,3,4,5,6)
  t = (1,2,3)
  t += (4,5,6)  # t = (1,2,3,4,5,6)
  t = (1,2) * 3  # t =(1,2,1,2,1,2)
  t = (1,2)
  t *= 3

比较运算:

• < <= > >= == !=
• 比较规则与列表的比较规则完全相同
• in / not in运算符
  • 等同于列表的 in / not in 运算符
• 索引 和 切片
  • 索引取值和切片取值的规则与列表完全相同
  • 注: 元组不支持 索引赋值和切片赋值

序列相关的函数也能用于元组中

• len(x), max(x), min(x),
• sum(x), any(x), all(x)

字典 dict

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

创建字典的字面值方式:

• 字典的表示方式以{} 括起来,以冒号(? 分隔键值对,各键
  值对之间用逗号分隔开

• 创建空字典:
  d = {}

• 创建非空字典:
  d = {“姓名”: “tarena”, “年龄”: 15}
  d = {“one”: 1, “two”: 2}
  d = {1: “One”, 2: “二”, 3: [1,2,3]}
  d = {“a”: list(range(10))}
  d = {“a”: {“b”: 100, “c”:[1, 2, 3]}}

创建字典的构造函数 dict:

• dict() # 生成一个空的字典 等同于 {}
• dict(iterable) 用可迭代对象创建一个列表
• dict(**kwargs) 关键字传参形式生成一个字典

** 示例:**

    d = dict()   
    L = [ (1, 2), [3, 4], "AB" ]
    d = dict(L)  # {1: 2, 3: 4, 'A': 'B'}
    d = dict(name="tarena", age=15)
        # d = {'age': 15, 'name': 'tarena'}

• 字典的键必须为不可变类型的值

可变的类型有四种:

• list(列表), dict(字典), set(集合),
• bytearray(字节数组)
  (除上述四种其它为不可变类型)

字典基本操作

• 字典的键索引
• 语法:
  • 字典[键]
• 作用:
  • 用键获取字典的键对应的值

**示例: **

 d = {'name': 'tarena', 'age': 16}
 print(d['name'], "的年龄是", d['age'])

添加和修改字典的元素

• 语法:
  • 字典[键] = 值
• 说明:
  • 键不存在时,创建键,并让键绑定对应的值
  • 键存在,修改键绑定的值
    示例:
    d = {}
    d[‘name’] = “小张” # 添加一个键值对
    d[‘年龄’] = 20 # 添加一个键值对
    d[‘年龄’] += 1 # 修改’年龄’ 这个键对应的值

练习:
写一个程序,让用户分两次输入一个人的信息:
信息包含: 姓名 和 电话号码
让用户多个人的信息,当输入姓名为空时结束输入
把用户输入的数据存于字典中
姓名作为键, 电话号码作为值
最后打印存储数据的字典
如:
请输入姓名: 小张
请输入电话: 13888888888
请输入姓名: 小李
请输入电话: 13999999999
请输入姓名: <回车>
打印:
{“小张”: 13888888888, “小李”: 13999999999}

删除字典元素

• del 语句
  • 语法:
    • del 字典[键]

示例:

d = dict(name="小张", age=20)
del d['age']
print(d)  # {'name': '小张'}

字典的键判断 in , not in运算符

• 可以用 in 运算符判断一个键是否存在于字典中,如果存在
  则返回True, 否则返回False
  • not in 返回值与 in 相反

例如:

d = {'name' : 'tarena', 'age': 15}
'name' in d  # True
15 in d      # False
'age' not in d  # False

练习:
写程序,实现以下需求:
1. 将如下数据形成一个字典 seasons

   键           值
   1   ====>    '春季有1,2,3月'
   2   ====>    '夏季有4,5,6月'
   3   ====>    '秋季有7,8,9月'
   4   ====>    '冬季有10,11,12月'

2. 让用户输入一个整数代表这个季度,打印这个季度对应的
   信息,如果用户输入的信息不存在于字典内,则提示用户
   ‘信息不存在’

字典的迭代访问

• 字典是可迭代对象,字典只能对键进行迭代访问

示例:

• d = {0:‘零’, 5:‘伍’, 1:‘壹’, 2:‘贰’}
• for n in d:
  • print(n) # 0, 1, 2, 5

可以用于字典的函数:

  len(x)    返回字典的键值对的个数
  max(x)    返回字典的键的最大值
  min(x)    返回字典的键的最小值
  sum(x)    返回字典的所有键的和
  any(x)    真值测试,只对键进行测试,只要有一个键为真值
            结果就为True
  all(x)    真值测试,所有键的真值结果才为True

示例:
d = {0:‘零’, 5:‘伍’, 1:‘壹’, 2:‘贰’}
len(x)
…

示例:

d = {0:'零', 5:'伍', 1:'壹', 2:'贰'}
for t in d.items():
    print(t)   # (0, '零'), (1, '壹'), (2, '贰'), (5, '伍')

for k, v in d.items():
    print("键是", k, '值是', v)

练习:

  输入一段字符串，打印出这个字符串中出现过的字符及出现过
  的次数
    如:
      输入: abcdabcaba
    打印如下:
      a: 4次
      b: 3次
      d: 1次
      c: 2次
    注: 不要求打印顺序

字典推导式

• 字典推导式是用可迭代对象来创建字典的表达式

• 语法:

  • {键表达式: 值表达式 for 变量 in 可迭代对象
    • [if 真值表达式]}
  • 注: []的内容代表可省略

示例:

• 生成一个字典: 键为数字0~９, 值为键的平方
• 如生成 {0: 0, 1:1, 2:4, 3: 9, … 9:81}
• d = {x: x**2 for x in range(10)}
• print(d)

字典推导式的嵌套

• 语法同列表推导式嵌套

练习:

  已知有如下字符串的列表:
    L = ['Tarena', 'XiaoZhang', 'xiaowang']
  生成如下字典:
    d = {'Tarena':6, 'XiaoZhang':9,
          'xiaowang':8}

练习:
  Nos = [1001, 1002, 1005, 1006]
  names = ['Tom', 'Jerry', 'Spike', 'Tyke']
  试生成如下字典:
    d = {1001: 'Tom', 1002: 'Jerry',
         1005: 'Spike', 1006: 'Tyke'}

  答案:
    d = {Nos[i]: names[i] for i in range(4)}

字典　VS 列表

1. 都是可变的容器
2. 索引方式不同，列表用整数索引，字典用键索引
3. 列表的存储是有序的，字典的存储是无序的
4. 字典的插入，删除，修改的速度可能会快于列表(重要)

问题:
L = [1, 3, 5, 8, 10]
for x in L:
L.remove(x)

print(L) # [3, 8]

练习:

1. 生成前40个斐波那契数 (Fibonacci 数列)
   　 1 1 2 3 5 8 13 21 …
   要求: 将这些数存入在列表中
   最后打印出这些数
2. 有一只小猴子，摘了很多桃,
   第一天吃了全部的桃子的一半，感觉不饱又吃了一个
   第二天吃了剩下的一半，感觉不饱又吃了一个
   以此类推…
   到第10天，发现只剩下一个了
   问: 第一天摘了多少桃子?
3. 打印九九乘法表:
   1x1=1
   1x2=2 2x2=4
   1x3=3 2x3=6 3x3=9
   …
   …9x9=81