python1.day15

day14回顾
   异常
     错误
     异常
     作用:
       用作信号通知
     语句:
       try-except语句
         捕获异常，将程序由异常流程转为正常流程
       try-finally语句
         保证（正常/异常)流程时，有些语句一定能执行
       raise 语句
         触发异常通知，让程序进入异常流程
       assert 语句
         根据条件触发AssertionError类型的错误
     异常类型:
        ValueError, ImportError, ZeroDivisionError,
        StopIteration, AssertionError, ....
        BaseExcetion(基类)

  迭代器
     什么是迭代器?
       函数:
         iter(可迭代对象)   获取并返回迭代器
         next(迭代器)    从迭代器中取数据,如果没有数据时会收到
                        StopIteration异常通知

    for in 语句的实质是while语句+迭代器+try语句的组合

day15笔记:
生成器 Genertor (python2.5及之后)
   什么是生成器
     生成器是能够动态提供数据的可迭代对象
     生成器是在程序运行时生成数据，与容器类不同，它通常不会在内
       存在中保存大量的数据，而是现用现生成

  生成器有两种:
     生成器函数
     生成器表达式
  
生成器函数的定义
   含有yield 的语句的函数是生成器函数。此函数被调用将返回一
   个生成器对象
   yield翻译为(产生或生成)

yield语句
   语法:
      yield 表达式
   说明:
     yield 用于def函数中，目的是将此函数作为生成器函数使用
     yield 用来生成数据，供迭代器的next(it) 函数使用
  示例见:
     yield.py
 

# yield.py

# 此示例示意生成器函数的定义和使用
def myyield():
    print("即将生成2")
    yield 2  # 生成2
    print("即将生成3")
    yield 3  # 生成3
    print("即将生成5")
    yield 5
    print("即将生成7")
    yield 7
    print("myyield函数运行结束!")



g = myyield()  # 生成器函数调用将返回生成器对象,g绑写一个生成器
# print(g)
it = iter(g)  # 让生成器提供迭代器
print(next(it))  # 2

print(next(it))  # 3

print(next(it))  # 5

print(next(it))  # 7

print(next(it))  # StopIteration异常
print("程序正常结束")

# yield.py

# 此示例示意生成器函数的定义和使用
def myyield():
    print("即将生成2")
    yield 2  # 生成2
    print("即将生成3")
    yield 3  # 生成3
    print("即将生成5")
    yield 5
    print("即将生成7")
    yield 7
    print("myyield函数运行结束!")

for x in myyield():
    print(x)


print("程序正常结束")

生成器函数说明:
   1. 生成器函数的调用将返回一个生成器对象，生成器对象是一个可迭
      代对象
   2. 在生成器函数调用return会触发一个StopIteration异常(即
      生成数据结束)
   生成器函数示例见:
     myinteger.py

# myinteger.py

# 此示例示意自己写一个生成器函数，可以生成从0开始的一系列
# 整数，到n结束(不包含n)
def myinteger(n):
    i = 0
    while i < n:
        yield i
        i += 1


for x in myinteger(3):
    print(x)

练习:
   1. 写一个生成器函数myeven(begin, end), 用来生成从begin开始
      到end结束的所有偶数(不包含end)
     如:
         def myeven(begin, end):
             ... 此处自己实现

        for x in myeven(1, 10):
             print(x)  # 打印 2, 4, 6, 8
         L = [x**2 for x in myeven(4, 9)]
         print(L)  # [16, 36, 64]

# 练习:
#   1. 写一个生成器函数myeven(begin, end), 用来生成从begin开始
#      到end结束的所有偶数(不包含end)
#     如:
#         def myeven(begin, end):
#             ... 此处自己实现

#         for x in myeven(1, 10):
#             print(x)  # 打印 2, 4, 6, 8
#         L = [x**2 for x in myeven(4, 9)]
#         print(L)  # [16, 36, 64]


def myeven(begin, end):
    i = begin
    while i < end:
        if i % 2 == 0:  # 是偶数
            yield i
        i += 1

for x in myeven(1, 10):
    print(x)  # 打印 2, 4, 6, 8

L = [x**2 for x in myeven(4, 9)]
print(L)  # [16, 36, 64]

生成器表达式:
   语法:
     (表达式 for 变量 in 可迭代对象 [if 真值表达式])
   说明:
     if 子句可以省略
   作用:
     用推导式形式创建一个新的生成器
   示例:
     gen = (x**2 for x in range(1, 5))
     it = iter(gen)  # 拿到迭代器
     print(next(it))  # 1
     print(next(it))  # 4
     print(next(it))  # 9
     print(next(it))  # 16
     print(next(it))  # StopIteration

说明:
   生成器通常是一次性的，当数据获取完毕后将不能再提供数据

练习:
   已知有列表:
     L = [2, 3, 5, 7]
   1. 写一个生成器函数，让此函数能够动态提供数据，数据为原列
      表的数字的平方加1
   2. 写一个生成器表达式，让此表达式能够动态提供数据，数据为原
      列表的数字的平方加1
   3. 创建一个列表，此列表内的数据为原列表L的数字的平方加1

# 练习:
#   已知有列表:
#     L = [2, 3, 5, 7]
#   1. 写一个生成器函数，让此函数能够动态提供数据，数据为原列
#      表的数字的平方加1
#   2. 写一个生成器表达式，让此表达式能够动态提供数据，数据为原
#      列表的数字的平方加1
#   3. 创建一个列表，此列表内的数据为原列表L的数字的平方加1



L = [2, 3, 5, 7]
#   1. 写一个生成器函数，让此函数能够动态提供数据，数据为原列
#      表的数字的平方加1
def fun1(lst):
    for x in lst:
        yield x ** 2 + 1

# for x in fun1(L):
#     print(x)

#   2. 写一个生成器表达式，让此表达式能够动态提供数据，数据为原
#      列表的数字的平方加1

for x in (a ** 2 + 1 for a in L):
    print(x)

#   3. 创建一个列表，此列表内的数据为原列表L的数字的平方加1
L = [a ** 2 + 1 for a in L]
print(L)

练习:
   试写一个生成器函数 myfilter,要求此函数与系统内建的filter
   函数功能完全一致
     如:
         def myfilter(fn, iterable):
             ....
        
         for y in myfilter(lambda x: x%2==0, range(10)):
             print(y)

# 练习:
#   试写一个生成器函数 myfilter,要求此函数与系统内建的filter
#   函数功能完全一致
#     如:
#         def myfilter(fn, iterable):
#             ....

#         for y in myfilter(lambda x: x%2==0, range(10)):
#             print(y)




def myfilter(fn, iterable):
    for x in iterable:
        if fn(x):
            yield x

for y in myfilter(lambda x: x%2==0, range(10)):
    print(y)

   2. 看下列语句块的输出结果是什么？为什么?
     第一个程序:
         L = [2, 3, 5, 7]
         A = [x*10 for x in L]
         it = iter(A)
         print(next(it))  # 20
         L[1] = 33
         print(next(it))  # 30
     第二个程序:
         L = [2, 3, 5, 7]
         A = (x*10 for x in L)
         it = iter(A)
         print(next(it))  # 20
         L[1] = 33
         print(next(it))  # 330

迭代工具函数
   zip 函数
  enumerate 函数

zip函数
   zip(itere1[,iter2, ....])  返回一个zip生成器对象，此对象
              用于生成一个元组，此元组的数据分别来自于参数中的
              每个可迭代对象,生成元组的个数由最小的可迭代对象大
              小决定
   示例:
     numbers = [10086, 10000, 10010, 95588]
     names = ['中国移动', '中国电信', '中国联通']
     for t in zip(numbers, names):
         print("t=", t)
     for n, na in zip(numbers, names):
         print(na, '的客服电话是:', n)

    d = dict(zip(numbers, names))  # 创建字典

    for t in zip(numbers, names, range(1, 100000)):
         print(t)

zip 函数的实现原理示例见:
     myzip.py

enumerate 函数
   格式:
     enumerate(iterable, start=0)
   作用:
     生成一个枚举对象，此枚举对象生成的数据将原可迭代对象的数据与
     索引值形成元组(index, value) 形式返回
   示例:
     L = [3, 5, 8, 10]
     for i, v in enumerate(L):
         print('索引为', i, '的元素值为', v)

练习:
   试用自己的方法实现myenumerate, 功能与enumerate完全相同
     def myenumerate(iterable, start=0):
         ...  # 此处自己实现

    L = [3, 5, 8, 10]
     for i, v in myenumerate(L):
         print('索引为', i, '的元素值为', v)

# 练习:
#   试用自己的方法实现myenumerate, 功能与enumerate完全相同
#     def myenumerate(iterable, start=0):
#         ...  # 此处自己实现

#     L = [3, 5, 8, 10]
#     for i, v in myenumerate(L):
#         print('索引为', i, '的元素值为', v)


# 方法1 用while语句实现
# def myenumerate(iterable, start=0):
#     it = iter(iterable)  # 拿到迭代器
#     while True:
#         try:
#             v = next(it)  # 拿到一个值
#             yield (start, v)
#             start += 1
#         except StopIteration:
#             return

# 方法2 用for语句实现
def myenumerate(iterable, start=0):
    for v in iterable:
        yield (start, v)
        start += 1

L = [3, 5, 8, 10]
for i, v in myenumerate(L):
    print('索引为', i, '的元素值为', v)

字节串和字节数组

字节串 bytes(也叫字节序列)
   作用:
     存储以字节为单位的数据
     字节串是不可变的字节序列
字节:
   字节是0~255之间的整数。用来表一个字节(8个位)的取值
   字节是数据存储的最小单位

创建空字节串的字面值:
    B = b''   # B绑定空字节串
    B = b""
    B = b''''''
    B = b""""""

创建非空字节串的字面值:
   B = b'ABCD'
   B = b"ABCD"
   B = b'x41x42x43x44'

字节串的构造函数 bytes
   bytes()   生成一个空的字节串,等同于b''
   bytes(整数可迭代对象)  用可迭代对象初始化一个字节串
   bytes(整数n)    生成n个值为0的字节串
   bytes(字符串,encoding='utf-8')   用字符串转换编码生成一个
         字节串

示例:
   B = bytes()                    # B=b''
   B = bytes(range(65, 69))       # B = b'ABCD'
   B = bytes(10)                  # B=b'x00x00....'
   B = bytes("hello", 'utf-8')    # B=b'hello'

bytes 的运算:
   +  +=  *  *=
   < <= > >= == !=
   in / not in
   索引和切片

示例:
   b = b'abc123ABC'
   b'A' in b  # True
   65 in b   # True
   print(b[0])  # 97

函数:
   len(x), max(x), min(x), sum(x), any(x), all(x)

bytes 与 str的区别:
   bytes 存储字节(0~255)
   str存储unicode字符  (0~0x10FFFF)

bytes与str转换
         编码(encode)
   str   -----------> bytes
       b = s.encode(encoding='utf-8')

　　　　　解码(decode)
   bytes  -----------> str     
       s = b.decode(encoding='utf-8')

  示例:
     s = "ABC中文"
     b = s.encode('utf-8')  # b = b'ABCxe4xb8xadxe6x96x87'

    s2 = b.decode('utf-8')  # s2 = 'ABC中文'

字节数组　bytearray
   可变的字节序列

字节数组的构造函数 bytearray
    (同字节串)
   bytearray()   生成一个空的字节数组,等同于bytearray(b'')
   bytearray(整数可迭代对象)  用可迭代对象初始化一个字节数组
   bytearray(整数n)    生成n个值为0的字节数组
   bytearray(字符串,encoding='utf-8')   用字符串转换编码生成一个
         字节数组

运算:
   +  +=  *  *=
   < <= > >= == !=
   in / not in
   索引Index / 切片 slice
   (注: 字节数组的索引和切片可以赋值操作，规则同列表的索引和切片
   赋值规则相同)

bytearray 的方法:
   参见文档:
     python_base_docs_html/bytearray.html

文件 File
   什么是文件
     文件是用于数据存储的单位
     文件通常用来长期存储数据
     文件中的数据是以字节为单位进行顺序存储的
 
   文件操作的流程
     1. 打开文件
     2. 读写文件
     3. 关闭文件

  文件的打开和关闭:
     文件需要在使用时先打开文件才能读写
     在不需要读写文件时，应及时关闭文件以释放系统资源
     任何操作系统，一个应用程序同时打开文件的数量有最大数限制

  文件的打开函数:
     open(file, mode='rt')  用于打开一个文件，返回此文件对象
                      如果打开失败，则会触发OSError类型的错误
        
  文件的关闭方法:
    F.close()  关闭文件，释放系统资源
   文本文件的读取数据方法:
     F.read([n])
     F.readline()
     F.readlines()
     (文档参见: python_base_docs_html/文件.html)

mode 模式字符的含义
字符	含义
'r'	以只读方式打开(默认)
'w'	以只写方式打开，删除原有文件内容(如果文件不存在，则创建该文件并以只写方式打开)
'x'	创建一个新文件, 并以写模式打开这个文件,如果文件存在则会产生"FileExistsError"错误
'a'	以只写文件打开一个文件，如果有原文件则追加到文件末尾
'b'	用二进制模式打开
't'	文本文件模式打开 (默认)
'+'	为更新内容打开一个磁盘文件 (可读可写)
缺省模式是 'rt'
'w+b' 可以实现二进制随机读写，当打开文件时，文件内容将被清零
'r+b' 以二进制读和更新模式打开文件,打开文件时不会清空文件内容
'r+' 以文本模式读和更新模式打开文件,打开文件时不会清空文件内容
python 文件常用方法:
方法	说明
F.close()	关闭文件(关闭后文件不能再读写会发生ValueError错误)
F.readline()	读取一行数据, 如果到达文件尾则返回空行
F.readlines(max_chars=-1)	返回每行字符串的列表,max_chars为最大字符(或字节)数
F.writelines(lines)	每行字符串的列表
F.flush()	把写入文件对象的缓存内容写入到磁盘
F.read(size = -1)	从一个文件流中最多读取size个字符
F.write(text)	写一个字符串到文件流中，返回写入的字符数
二进制文件操作方法
F.tell()	返回当前文件流的绝对位置
F.seek(offset, whence=0)	改变数据流的位置，返回新的绝对位置
F.readable()	判断这个文件是否可读,可读返回True,否则返回False
F.writable()	判断这个文件是否可写,可写返回True,否则返回False
F.seekable()	返回这个文件对象是否支持随机定位
F.truncate(pos = None)	剪掉 自pos位置之后的数据，返回新的文件长度(字节为单位)

   示例见:
     file_open.py

# file_open.py

# 此示例示意打开一个文件， 同时对文件的内容进行读取操作

# 1. 打开文件
# f = open("myzip.py")
f = open("myfile.txt")
print("文件打开成功")

# 2.读取文件

# 3. 关闭文件
f.close()
print("文件关闭成功")

练习:
   1. 写一个生成器函数myxrange(start, stop, step) 来生成一
     系列整数，
       要求:
         myxrange的功能与range功能完全相同
         不允许调用range函数和列表
        用自己写的myxrange结合生成器表达式求 1~10内的奇数的平方和
       print(sum((x for x in myxrange(1, 10) if x%2)))
    
   2. 自己写一个文件(si.txt)内容如下:
      写入内容如下:
        xiaozhang,20,100
        ziaoli,18,98
        ziaowang,19,80
     为学生信息管理系统添加一个功能
       | 9) 从文件中读取学生数据(si.txt) |
     读取学生信息并加载到内存中

# file : main.py

from menu import show_menu
from student_info import *

def main():
    infos = []  # 此列表用于保存学生数据
    while True:
        show_menu()
        s = input("请选择: ")
        if s == '1':
            infos += input_student()
        elif s == '2':
            output_student(infos)
        elif s == '3':
            delete_student(infos)
        elif s == '4':
            modify_student_score(infos)
        elif s == '5':
            output_by_score_desc(infos)
        elif s == '6':
            output_by_score_asc(infos)
        elif s == '7':
            output_by_age_desc(infos)
        elif s == '8':
            output_by_age_asc(infos)
        elif s == '9':
            infos = read_from_file()
        elif s == '10':
            save_to_file(infos)  # 保存
        elif s == 'q':
            break

main()

# file : menu.py


def show_menu():
    '''显示菜单'''
    print("+---------------------------------+")
    print("| 1) 添加学生信息                 |")
    print("| 2) 显示学生信息                 |")
    print("| 3) 删除学生信息                 |")
    print("| 4) 修改学生成绩                 |")
    print("| 5) 按学生成绩高-低显示学生信息  |")
    print("| 6) 按学生成绩低-高显示学生信息  |")
    print("| 7) 按学生年龄高-低显示学生信息  |")
    print("| 8) 按学生年龄低-高显示学生信息  |")
    print("| 9) 从文件中读取学生数据(si.txt) |")
    print("| 10) 保存信息到文件(si.txt)      |")
    print("| q) 退出                         |")
    print("+---------------------------------+")

# file: student.py

def input_student():
    L = []  # 创建一个列表,准备存放学生数据的字典
    while True:
        n = input("请输入姓名: ")
        if not n:  # 如果用户输入空字符串就结束输入
            break
        try:
            a = int(input("请输入年龄: "))
            s = int(input("请输入成绩: "))
        except ValueError:
            print("您的输入有错，请重新输入!!!")
            continue
        d = {}  # 一定要每次都创建一个新的字典
        d['name'] = n
        d['age'] = a
        d['score'] = s
        L.append(d)   # 把d加入列表中L
    return L

def output_student(L):
    print("+---------------+----------+----------+")
    print("|     姓名      |   年龄   |   成绩   |")
    print("+---------------+----------+----------+")
    for d in L:
        name = d['name']
        age = str(d['age'])  # 转为字符串
        score = str(d['score'])  # 转为字符串
        print("|%s|%s|%s|" % (name.center(15),
                            age.center(10),
                            score.center(10)))
    print("+---------------+----------+----------+")

def delete_student(L):
    name = input("请输入要删除学生的姓名: ")
    i = 0  # i 代表列表的索引
    while i < len(L):
        d = L[i]  # d绑定字典
        if d['name'] == name:
            del L[i]
            print("删除", name, "成功!")
            break
        i += 1
    else:
        print("删除失败!")

def modify_student_score(L):
    pass


def output_by_score_desc(L):
    def get_score(d):
        return d['score']
    L2 = sorted(L, key=get_score, reverse=True)
    output_student(L2)

def output_by_score_asc(L):
    L2 = sorted(L, key=lambda d:d['score'])
    output_student(L2)

def output_by_age_desc(L):
    L2 = sorted(L, key=lambda d:d['age'], reverse=True)
    output_student(L2)

def output_by_age_asc(L):
    L2 = sorted(L, key=lambda d:d['age'])
    output_student(L2)


def read_from_file():
    L = []  # 创建一个准备存放字典的列表
    try:
        # 1. 打开文件
        # f = open("./si.txt")
        # f = open("si.txt")
        f = open("/home/tarena/aid1812/pbase/day16/student_project/si.txt")
        # 2. 读取信息
        try:
            while True:
                line = f.readline()  # line='xiaozhang,20,100
'
                if not line:  # 到达文件尾
                    break
                s = line.strip()  # 去掉左右两端的空白字符'xiaozhang,20,100'
                lst = s.split(',')  # ['xiaozhang', '20', '100']
                n = lst[0]
                a = int(lst[1])
                scr = int(lst[2])
                d = dict(name=n, age=a, score=scr)
                L.append(d)
        finally:
            # 3. 关闭文件
            f.close()
            print("读取数据成功")
    except OSError:
        print("读取数据失败")
    except ValueError:
        print("数据类型错误！")
    return L

def save_to_file(L):
    try:
        f = open("si.txt", 'w')
        # 循环写入每个学生的信息
        for d in L:
            # 每次写入一个学生的信息
            f.write(d['name'])  # 姓名
            f.write(',')
            f.write(str(d['age']))  # 年龄
            f.write(',')
            f.write(str(d['score']))  # 成绩
            f.write('
')  # 换行
        f.close()
        print("保存成功")
    except OSError:
        print("保存失败!")