python 基础篇 第八节课

文件处理b模式

f = open("你不好","rb")
data = f.read()
print(data)
print(data.decode("utf8")
      
#输出b'hahahahahah\r\ngaojianshishabi '
#hahahahahah
#gaojianshishabi 

f = open("你不好","wb")
f.write(bytes("hahahaha\n",encoding="utf8"))

f = open("你不好","ab")
f.write("帅哥".encode("utf8"))

f = open("我是李怕怕","w",encoding="gbk")
print(f.closed)
print(f.encoding)

#输出False
#     gbk

 

f = open("我是李怕怕","r+",encoding="gbk")
f.flush()       #刷新，文件内容从内存刷新到硬盘
print(f.tell()) #查看当前文件处理的光标位置
f.seek(10,1)    #控制光标的移动 ，1是相对位置
f.seek(-5,2)    #倒序
f.truncate(10)  #截取，从头开始算，将文件只保留从0-10个字节的内容，文件必须以写方式打开，但w和w+除外

f = open("日志文件","rb")
data = f.readlines()
print(data[-1].decode("utf8"))

#输出啊哈哈 读文件最后一行

f = open("日志文件","rb")
for i in f:
    offs = -10
    while True:
        f.seek(offs,2)
        data  = f.readlines()
        if len(data) >1:
            print("文件最后一行%s" %(data[-1].decode("utf8")))
            break
        offs *=2
        
#输出文件最后一行啊哈哈

迭代器和生成器

1迭代器协议：对象必须提供一个Next方法，执行方法要么返回迭代中的下一项，要么引起一个stoplteration异常，以终止迭代（只能往前不能后退）

2可迭代对象：实现了迭代协议的对象

3协议是一种约定，可迭代对象实现了迭代器的协议，python的内部工具，试用迭代器协议访问对象

X = "Hello"
iter_test = X.__iter__()
# print(list(iter_test))
# print(iter_test.__next__())
# print(iter_test.__next__())        for i in X:
# print(iter_test.__next__())   =       print(i) 
# print(iter_test.__next__())
# print(iter_test.__next__())

#输出
# H
# e
# l
# l
# o

l = [1,2,3]
iter_l = l.__iter__()
print(iter_l.__next__())            #print(l[0])
print(iter_l.__next__())            ##print(l[1])
print(iter_l.__next__())            ##print(l[2])

for i in l:
    print(i)

index = 0
while index < len(l):
    print(l[index])
    index +=1

#输出
# 1
# 2
# 3

# 字典
dic = {"a":1,"b":2}
iter_d = dic.__iter__()
print(iter_d.__next__())    #keys

l = [1,2,3,4,5,6,7,8,9]
diedai = l.__iter__()
while True:
    try:
        print(diedai.__next__())
    except StopIteration:
        print("迭代完毕了，循环终止")
        break


#输出
1
2
3
4
5
6
7
8
9
迭代完毕了，循环终止

l = ["erzi","laozi","sunzi"]
iter_l = l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())
print(next(iter_l))


#输出
erzi
laozi
sunzi

生成器

可以理解为一种数据类型，这种数据类型自动实现迭代协议，所以生成器就是可迭代对象

1生成器函数：常规函数定义，试用yeild语句

def test():
    yield  1
g = test()
print(g)

2生成器表达式

三元表达式

name = "GJ"
res = "sb" if name == "GJ" else "帅哥"   # true------>sb     false ------->帅哥
print(res)

#输出sb

列表解析

egg_list = []
for i in range(10):
    egg_list.append("鸡蛋%s" %i)
print(egg_list)


#另一种写法
l = ["鸡蛋%s" %i for i in range(10)]
print(l)

l1 = ["鸡蛋%s" %i for i in range(10) if i > 5]
print(l1)

laomuji = ["母鸡%s" %i for i in range(10)]  #生成器表达式
print(laomuji)
laomuji_1= laomuji.__iter__()
print(laomuji_1.__next__())
print(laomuji_1.__next__())
print(next(laomuji_1))
print(next(laomuji_1))

#输出
# ['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
# ['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
# ['鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
# ['母鸡0', '母鸡1', '母鸡2', '母鸡3', '母鸡4', '母鸡5', '母鸡6', '母鸡7', '母鸡8', '母鸡9']
# 母鸡0
# 母鸡1
# 母鸡2
# 母鸡3

总结：1 把列表解析的[]换成（）得到的就是生成器表达式

　　　2列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

　　　3python不但使用迭代器协议，让for循环变的更加通用，大部分内置函数，也是试用迭代器协议访问对象的。