day07

day06回顾

• 列表
  方法:
  L.append(x)
  L.extend(iterable) +=
  L.insert(索引位置，值)
  L.remove(x) # 删除
  L.clear()
  L.pop([索引]) 取出
  L.copy() 复制
  L.count(元素,begin,end) 计数
  L.sort(reverse=False)
  L.reverse() 反转

• len(x) 求长度
  max(可迭代对象)/max(值1,值2,…)
  min(可迭代对象)/min(值1,值2,…)
  sum(可迭代对象) # 求和
  any(可迭代对象)
  all(可迭代对象)

• 列表是可变的对象
  浅拷贝和深拷贝
  变量1 = 变量2 # 不复制
  变量1 = 列表2.copy() # 浅拷贝
  import copy
  变量1 = copy.deepcopy(列表2) # 深拷贝

• 字符串的方法:
  str.split()
  str.join()

• 列表推导式:
  [表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 …]

day07笔记

元组 tuple（不可变）

• 元组是不可变的序列，同list一样，元组可以存放任意类型的数据

  • 表示方式:
    用小括号()括起来,单个元素括起来后加逗号(,) 区分单个对象还是元组
    创建空元组的字面值:
    t = () # 空元组
    创建非空元组的字面值表示
    t = 200, # 含有一个元素的元组
    t = (20,) # 含有一个元素的元组
    t = (1, 2, 3)
    t = 100, 200, 300

• type(x) 函数返回一个对象的类型

• 元组的错误示例:
  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”

• 元组的构造函数
  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)
   t = (1,2,3) * 2
   t *= 3  

• 比较运算:
  规则等同于列表的比较规则

  (1, 3, 2) > (1, 2, 3)  # True
  (1, 2, 3) > (1, 2)  # True
  (1, '二') > ('二', 1)  # TypeError
  (1, '二') != ('二', 1)  # True

• in / not in 运算符
  同列表的in运算符相同，用于检查一个值是否存在元组中，如果存在返回True,否则返回False
  not in 与 in 返回值相反
  如:

    2 in (1, 2, 3)  # True
    100 in (1, 2, 3)  # False
    "abc" not in (1,2,3)  # True

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

• len(x) / max(x) / min(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

• 什么是字典

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

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

• 创建空字典的字面值:
  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, ‘address’: “北京市海淀区”}

• 删除字典键值对
  del 语句
  语法:
  del 字典[键]

  • 示例:
    d = {‘name’: ‘tarena’, ‘age’: 30}
    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:
     键 值
     1 ----> ‘春季有1,2,3月’
     2 ----> ‘夏季有4,5,6月’
     3 ----> ‘秋季有7,8,9月’
     4 ----> ‘冬季有10,11,12月’

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

• 字典的迭代访问:
  字典是可迭代对象,字典只能对键进行迭代访问
  示例:
  d = {‘name’: ‘tarena’, (2002,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:‘捌’, 3:‘叁’}
    len(d) # 4
    max(d) # 8
    min(d) # 0
    sum(d) # 16
    any(d) # True
    all(d) # False

• 字典的方法

• 示例:

    d1 = {1: "One", 2: "Two"}
    d2 = {2: "二", 3:'三'}
    d1.update(d2)
    # 合并后 d1 = {1: 'One', 2: '二', 3: '三'}
    d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
    for k in d.keys():
        print(k)  # 0 5 8 3
    for  v in d.values():
        print(v)  # 零 伍 捌 叁

    for t in d.items():  # t 绑定元组
        print(t)  # (0,'零') (5,'伍')
    
    for k, v in d.items():
        print(k,'的值是', v)

• 练习:
  输入一段字符串,打印出这个字符串中出现过的字符及出现过的次数
  如:
  输入:ABCDABCABA
  打印:
  a: 4次
  b: 3次
  d: 1次
  c: 2次

• 字典推导式
  字典推导式是用可迭代对象依次生成字典内元素的表达式
  语法:
  {键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
  注: [] 的内容代表可省略
  示例:
  # 生成一个字典,键为数字1~9,值为键的平方
  d = {x: x**2 for x in range(1, 10)}
  {1:1, 2:4, 3:9, …}

  有如下字符串:
  L = [‘tarena’, ‘xiaozhang’, ‘hello’]

  要生成键为单词,值为单词长度的字典:

  {'tarena': 6, 'xiaozhang': 9, 'hello': 5}
  

  d = {s: len(s) for s in L}

• 字典 vs 列表

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

• 练习:
  1.已知有两个等长的列表
  list1 = [1001, 1002, 1003, 1004]
  list2 = [“Tom”, “Jerry”, “Spike”, “Tyke”]
  写程序生成如下字典:
  {“Tom”: 1001, “Jerry”:1002, “Spike”:1003, “Tyke”: 1004}

  2. 任意输入多个学生的姓名,年龄,成绩,每个学生信息存入一个字典中,然后再放入列表中(每个学生信息需要手动输入)
     如:
     请输入姓名: tarena
     请输入年龄: 15
     请输入成绩: 99
     请输入姓名: name2
     请输入年龄: 22
     请输入成绩: 100
     请输入姓名: <直接回车结束输入>
     在程序内部生成如下列表:
     L = [{‘name’: tarena, ‘age’:15, ‘score’: 99}, {‘name’: name2, ‘age’:22, ‘score’: 100}]
  1. 打印出上述列表
  2. 以下列表格的形式打印出上述信息

    +---------------+-----------+----------+
    |     name      |    age    |  score   |
    +---------------+-----------+----------+
    |    tarena     |    15     |    99    |
    |     name2     |    22     |   100    |
    +---------------+-----------+----------+