day06回顾
   列表
     可变的序列容器
   创建列表的方法:
     字面值 [], [1, 2, 3]
     构造函数 list() , list(range(10))
     推导式 [x**2 for x in range(10)]
   运算符:
     + += * *=
     <  <=  >  >=  ==  !=
     in / not in
     索引
       索引取值
         v = L[1]
       索引赋值
         L[1] = 100

切片
       切片取值
         L[a:b]    L[a:b:c]  注意: 切片取值返回的是列表
       切片赋值
         L[a:b] = 可迭代对象
         L[a:b:c] = 可迭代对象
       当c不等同于1时,切片赋值,切出的段数等于可迭代对象提供
         的个数

可以用于序列的函数:
   len(x), max(x), min(x), sum(x), any(x), all(x)

reversed(x)  返转迭代输出的顺序
   sorted(x, reverse=False)  对x迭代取出的数据进行排序,
             返回排序后的列表
  
列表的方法:
   L.index(v)
   L.append(x)  追加
   L.count(x)
   L.extend(可迭代对象)  #  扩展
   L.copy()  # 复制
   L.reverse()  # 反转
   L.remove(x)  # 按值来删除第一个
   L.clear()   # 全删除
   v = L.pop([index])  按索引来移除元素
   L.sort(reverse=False)  将列表中的元素进行排序

深拷贝, 浅拷贝
  
字符串的解析方法:
   S.split(sep=None)  # 用sep拆分为列表
   S.splitlines()    # 用换行符拆分为列表
   S.join(iterable)  # 将列表组合成为字符串

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

day07笔记
元组 tuple
   元组是不可改变的序列,同list一样,元组是可以存入任意类型数据
      的容器

元组的表示方式:
   用小括号()括起来,单个元素括起来后加逗号(,)区分单个对象还是
   元组
创建空元组的字面值
   t = ()
创建非空元组的字面值
    t = 200,
    t = (20,)
    t = (1, 2, 3)
    t = 100, 200, 300
注:
   type(x) 函数用来返回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() 生成一个空的元组,等同于()
   tuple(iterable) 用可迭代对象生成一个元组
示例:
   t = tuple()   创建空元组,等同于 t = ()
   t = tuple(range(1, 10, 3))  # 创建非空元组

元组的运算:
   运算符:
     +  +=   *  *=
   + 加号用于拼接
    t = (1, 2, 3) + (4, 5, 6)  # t = (1, 2, 3, 4, 5, 6)
   +=  拼接后再赋值
     x = (1, 2, 3)
     y = (4, 5, 6)
     x += y    # 等同于 x = x + y
     注: 因为元组不可变,加后的ID会发生变化
    
   * 生成重复的元组
   *= 生成重复的元组再重新赋值绑定
     x = (1, 2) * 3
     print("x=", x)
     x = (1, 2, 3)
     x *= 2   # x = (1, 2, 3, 1, 2, 3)

元组的比较运算
   运算符:
     < <= > >= == !=
   说明:
     元组比较规则和列表比较规则完全相同

in / not in 运算符:
    x = (1, 'two', 3)
    2 in x  # False
    3 in x  # True
    5 in x  # False
    5 not in x  # True

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

切片 slice
   用法等同于列表的切片,元组的切片返回一个新的元组
   元组不能切片赋值

元组的方法:
   文档参见:
     python_base_docs_html/tuple.html

序列相关的函数总结:
    # 以下函数可以用于序列: 字符串,列表,元组
    len(x) , max(x), min(x), sum(x), any(x), all(x)

构造函数:
     str(x)
     list(x)
     tuple(x)

reversed(x) , sorted(x, reverse=False)

练习:
   生成一个1~9的平方的元组,元组如下:
     (1, 4, 9, 16, 25, ...., 81)

  1 #   生成一个1~9的平方的元组,元组如下:
  2 #     (1, 4, 9, 16, 25, ...., 81)
  3
  4 # 方法1
  5 # t = ()
  6 # for x in range(1, 10):
  7 #     t += (x**2,)
  8
  9 # 方法2
 10 # L = [x ** 2 for x in range(1, 10)]
 11 # t = tuple(L)
 12
 13 # 方法3
 14 # t = tuple(x**2 for x in range(1, 10))
 15 # 等同于如下:
 16 g = (x**2 for x in range(1, 10))
 17 t = tuple(g)
 18
 19 print(t)
 20 

1~9

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

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

创建空字典的字面值:
    d = {}   # 空字典

创建非空的字典
  d = {'姓名': '小张', '年龄': 20}
   d = {1: '一', 2:"二", 5:'五'}

dict的构造(创建) 函数dict
   dict()           生成一个空的字典,等同于{}
   dict(iterable)   用可迭代对象创建一个字典
   dict(**kwargs)   用关键字传参形式生成一个字典(字典的键名
                 必须是符合标识符命名规则的字符串)

示例:
   d = dict()
   L = [('姓名', '小张'), ['年龄', 20], "AB"]
   d = dict(L)
   d = dict(name='小张', age=20)

字典的键(key) 必须为不可变的数据类型,可以用数字,字符串,
    元组等充当字典的键

python3中不可变的数据类型:
   bool, int, float, complex, str, tuple,
   frozenset(固定集合,后面才讲), bytes(字节串)
   包括: None
python3中可变的数据类型:
   列表list, 字典dict, set(集合), bytearray(字节数组)

示例:
     d = {'a': 100}
     d = {'a': (1, 2, 3)}
     d = {(1, 2, 3): 'a'}
     d = {'a': [1, 2, 3]}
     d = {[1, 2, 3]: 'a'}  # 报错,列表不能做为键
     d = {'a': {'b': 100, 'c': 200}}
     d = {{1:'一'}: '壹'}  # 报错,字典不能做键

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

添加和修改字典的键值对
   语法:
     字典[键] = 表达式
   说明:
     键不存在,创建键,并绑定键对应的值
     键存在,修改键绑定的值
   示例:
     d = {}
     d['name'] = 'tarena'  # 创建新键值对
     d['age'] = 15
     d['age'] = 16  # 修改age键对应的值为16

删除字典的元组 del语句
   语法:
     del 字典[键]
   作用:
     删除字典的键,同时解除对值的绑定
  示例:
     d = {'name': 'tarena', 'age': 20}
     del d['age']

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

示例:
     d = {'name': 'tarena', 'age': 15}
     'name' in d  # True
     30 in d  # False
     'tarena' in d  # False
     15 not in d    # True
   注: 只判断键是否存在,不判断值是否存在

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

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

  1 # 练习:
  2 #   写程序,实现以下要求:
  3 #   1. 将如下数据形成一个字典seasons
  4 #     '键'         '值'
  5 #      1  -----> '春季有1,2,3月'
  6 #      2  -----> '夏季有4,5,6月'
  7 #      3  -----> '秋季有7,8,9月'
  8 #      4  -----> '冬季有10,11,12月'
  9
 10 #     让用户输入一个整数代表这个季度,打印这个季度的信息,如果用户
 11 #     输入的信息不在字典内,则打印"信息不存在"
 12
 13 # 方法1
 14 # seasons = {
 15 #     1: '春季有1,2,3月',
 16 #     2: '夏季有4,5,6月',
 17 #     3: '秋季有7,8,9月',
 18 #     4: '冬季有10,11,12月'
 19 # }
 20 # 方法2
 21 seasons = {}
 22 seasons[1] = '春季有1,2,3月'
 23 seasons[2] = '夏季有4,5,6月'
 24 seasons[3] = '秋季有7,8,9月'
 25 seasons[4] = '冬季有10,11,12月'
 26
 27 # print(seasons)
 28 x = int(input('请输入季度(1~4):'))
 29 if x in seasons:
 30     print(seasons[x])
 31 else:
 32     print("信息不存在")
 33
 34
 35
 36
 37 

season

字典是可迭代对象
   字典只能对键进行迭代访问
  示例:
     d = {'name': 'tarena', 'birthday': (2002,1,1)}
     for k in d:
         print(k)

字典的比较运算:
   运算符:
     ==  != 
   说明:
     只有键和值都完全相同时,才相等,否则不相等
   示例:
     {1: '一', 2: '二'} == {1: '一', 2: '二'}  # True
     {1: '一', 2: '二'} == {1: '1', 2: '2'}  # False

可以用于字典的内建 函数
   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

字典的方法
   文档参见:
     python_base_docs_html/dict.html
   使用方法:
     字典.方法名(方法传参)

　示例:
    d1 = {1: 'one', 2: '二', 3: '三'}
    for t in d1.items():
        print(t)  # (1, 'one'), (2, '二'), (3, '三')

for k, v in d1.items():
        print('k=', k, 'v=', v)

练习:
   写一个程序，输入一个字符串，写程序统计出这个字符串的字符
   个数的字符的种类
   如:
     请输入: ABCDABCABA
   输出结果:
     字符 A: 4次
     字符 B: 3次
     字符 D: 1次
     字符 C: 2次
     （注: 不要求输出的顺序)

  1 # 练习:
  2 #   写一个程序，输入一个字符串，写程序统计出这个字符串的字符
  3 #   个数的字符的种类
  4 #   如:
  5 #     请输入: ABCDABCABA
  6 #   输出结果:
  7 #     字符 A: 4次
  8 #     字符 B: 3次
  9 #     字符 D: 1次
 10 #     字符 C: 2次
 11 #     （注: 不要求输出的顺序)
 12
 13 s = input("请输入: ")
 14 # 统计字符的个数:
 15 # 如果第一次出现这个字符:
 16 #　   用这个字符创建字典的键，值为1
 17 # 如果第二次或之后出现这个字符，直接将键对应的值加1
 18 d = {}
 19 for ch in s:
 20     if ch not in d:  # 第一次出现
 21         d[ch] = 1
 22     else:
 23         d[ch] += 1
 24
 25 # print('d=', d)
 26 for k in d:
 27     print("字符", k, ':', d[k], '次')
 28 

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

语法:
     {键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]　...}
     注: [] 的内容代表可省略
   示例:
     生成一个字典，键为数字(10以内), 值为键的平方
       d = {x : x ** 2 for x in range(10)}

练习:
   1. 有如下字符串列表:
     L = ['tarena', 'xiaozhang', 'hello']
   生成如下字典:
     d = {'tarena': 6, 'xiaozhang': 9, 'hello': 5}
     注: 字典的值为键的长度
   答案:
     d = {k: len(k) for k in L}

2. 已知有两个字符串列表:
     Nos = [1001, 1002, 1005, 1008]
     names = ['Tom', 'Jerry', 'Spike', 'Tyke']

生成以Nos 中项为键，以names中的项为值的字典
     d = {1001: 'Tom', 1002:'Jerry', ....}

  1 #   2. 已知有两个字符串列表:
  2 #     Nos = [1001, 1002, 1005, 1008]
  3 #     names = ['Tom', 'Jerry', 'Spike', 'Tyke']
  4
  5 #     生成以Nos 中项为键，以names中的项为值的字典
  6 #     d = {1001: 'Tom', 1002:'Jerry', ....}
  7
  8
  9
 10 Nos = [1001, 1002, 1005, 1008]
 11 names = ['Tom', 'Jerry', 'Spike', 'Tyke']
 12
 13 # d = {}
 14 # for i in range(len(Nos)):
 15 #     # print(i)
 16 #     d[c] = names[i]
 17
 18 d = {Nos[i]: names[i] for i in range(len(Nos))}
 19 # d = {x: y for x in Nos for y in names}  # 错误
 20
 21
 22
 23 print(d)
 24
 25
 26
 27
 28 

2.1

  1 #   2. 已知有两个字符串列表:
  2 #     Nos = [1001, 1002, 1005, 1008]
  3 #     names = ['Tom', 'Jerry', 'Spike', 'Tyke']
  4
  5 #     生成以Nos 中项为键，以names中的项为值的字典
  6 #     d = {1001: 'Tom', 1002:'Jerry', ....}
  7
  8
  9
 10 Nos = [1001, 1002, 1005, 1008]
 11 names = ['Tom', 'Jerry', 'Spike', 'Tyke']
 12
 13 # d = {}
 14 # for n in Nos:
 15 #     d[n] = names[Nos.index(n)]
 16
 17 d = {n: names[Nos.index(n)] for n in Nos}
 18
 19 print(d)
 20
 21
 22
 23
 24 

2.2

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

练习:
   1. 思考下面的程序的执行结果是什么？为什么？
   L = list(range(10))
      for x in L:
          L.remove(x)
      print("L=", L)  # 请问是空列表吗？

  1 #   1. 思考下面的程序的执行结果是什么？为什么？
  2 #   　　L = list(range(10))
  3 #      for x in L:
  4 #          L.remove(x)
  5 #      print("L=", L)  # 请问是空列表吗？
  6
  7
  8 L = list(range(10))
  9 # for x in L:
 10 #     print("+++++")
 11 #     L.remove(x)
 12
 13 while L:
 14     L.remove(L[0])
 15
 16 print("L=", L)  # 请问是空列表吗？
 17 

1

2. 输入一些单词和解释,将单词作为键,将解释作为值,存入字典中
      当输入单词或解释为空是停止输入,并打印这个字典

然后,输入查询的单词,给出单词的内容,如果单词不存在则提示:
        查无此词

  1 #   2. 输入一些单词和解释,将单词作为键,将解释作为值,存入字典中
  2 #      当输入单词或解释为空是停止输入,并打印这个字典
  3
  4 #      然后,输入查询的单词,给出单词的内容,如果单词不存在则提示:
  5 #        查无此词
  6
  7 mydict = {}  # 创建一个空字典准备存储数据
  8 while True:
  9     word = input("请输入单词: ")
 10     if not word:  # 如果word空字符串,则退出
 11         break
 12     trans = input("请输入解释: ")
 13     if not trans:
 14         break
 15     # 走到此处,说明word,  trans都绑定了正确的值
 16     mydict[word] = trans
 17
 18 print("mydict=", mydict)
 19
 20 print("-------------以下开始查词--------")
 21 while True:
 22     w = input('请输入您要查询的单词: ')
 23     if w in mydict:
 24         print("解释是:", mydict[w])
 25     else:
 26         print("查无此词!")
 27
 28 

2

3. <<学生信息管理项目>>
      输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典,然
      后放入列表中,每个学生的信息需要手动输入,当输入姓名为空时
      结束输入
     如:
       请输入姓名: tarena
       请输入年龄: 20
       请输入成绩: 99
       请输入姓名: name2
       请输入年龄: 18
       请输入成绩: 88
       请输入姓名: <回车> 结束输入
     内部存储格式如下:
       [{'name': 'tarena', 'age': 20, 'score':99},
        {'name': 'name2', 'age': 18, 'score':88}]
     打印上述此列表
     然后再用表格的形式打印学生信息如下:
     +---------------+----------+----------+
     |      姓名      |   年龄   |   成绩    |
     +---------------+----------+----------+
     |     tarena    |    20    |    99    |
     |     name2     |    18    |    88    |
     +---------------+----------+----------+

  1 # student_info.py
  2 #   3. <<学生信息管理项目>>
  3 #      输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典,然
  4 #      后放入列表中,每个学生的信息需要手动输入,当输入姓名为空时
  5 #      结束输入
  6 #     如:
  7 #       请输入姓名: tarena
  8 #       请输入年龄: 20
  9 #       请输入成绩: 99
 10 #       请输入姓名: name2
 11 #       请输入年龄: 18
 12 #       请输入成绩: 88
 13 #       请输入姓名: <回车> 结束输入
 14 #     内部存储格式如下:
 15 #       [{'name': 'tarena', 'age': 20, 'score':99},
 16 #        {'name': 'name2', 'age': 18, 'score':88}]
 17 #     打印上述此列表
 18 #     然后再用表格的形式打印学生信息如下:
 19 #     +---------------+----------+----------+
 20 #     |      姓名      |   年龄   |   成绩    |
 21 #     +---------------+----------+----------+
 22 #     |     tarena    |    20    |    99    |
 23 #     |     name2     |    18    |    88    |
 24 #     +---------------+----------+----------+
 25
 26 L = []  # 创建一个列表,准备存放学生数据的字典
 27 while True:
 28     n = input("请输入姓名: ")
 29     if not n:  # 如果用户输入空字符串就结束输入
 30         break
 31     a = int(input("请输入年龄: "))
 32     s = int(input("请输入成绩: "))
 33     d = {}  # 一定要每次都创建一个新的字典
 34     d['name'] = n
 35     d['age'] = a
 36     d['score'] = s
 37     L.append(d)   # 把d加入列表中L
 38
 39 print(L)
 40
 41
 42 print("+---------------+----------+----------+")
 43 print("|     姓名      |   年龄   |   成绩   |")
 44 print("+---------------+----------+----------+")
 45 for d in L:
 46     name = d['name']
 47     age = str(d['age'])  # 转为字符串
 48     score = str(d['score'])  # 转为字符串
 49     print("|%s|%s|%s|" % (name.center(15),
 50                           age.center(10),
 51                           score.center(10)))
 52
 53 # print("|     tarena    |    20    |    99    |")
 54 # print("|     name2     |    18    |    88    |")
 55 print("+---------------+----------+----------+")
 56 

3