2018-08-31 day10 文件操作

2018-08-31 本文已影响0人 rzlong

函数作为变量

在python中，函数就是一种特殊的类型，声明函数就是声明function类型的变量。

函数作为变量赋值给另外一个变量

def func1():
    return('func1')
a = func1 #将函数作为变量赋值给a，给的是函数地址
print(type(a))
func1() ##函数调用
b = func1()
print(b,func1(),func1)

result:
<class 'function'>
func1 func1 <function func1 at 0x00627FA8>

函数作为列表的元素

list1 = [func1] #例如将函数作为变量给列表的第一个元素
dict1 = {'func1':func1,'+':lambda *num:sum(num),'-':lambda x,y:x-y}
print(list1[0](),dict1)
print(dict1['func1'](),dict1['+'](1,2,3,4,5))

result:
func1 {'func1': <function func1 at 0x00627FA8>, '+': <function <lambda> at 0x00627F60>, '-': <function <lambda> at 0x00627E40>}
func1 15

函数可以作为函数的参数(回调函数)

def clear_kitchen(time):
    print('在%s时间内打扫厨房，收费200' % time)
    return 200
def clear_bedroom(time):
    print('在%s时间内打扫卧室，收费400' % time)
    return 400

def call_service(time, service):
    service(time)

call_service('10点',clear_bedroom)

result:
在10点时间内打扫卧室，收费400

函数作为函数的返回值

def operation(operator:str):
    if operator == '+':
        def sum2(*num):
            count = 0
            for item in num:
                count += item
            print(count)
            return count
        return sum2
#函数判断operator等于+，返回sum2函数，sum2开始执行
operation('+')(1,2,3,4,5) 

result:
15

生成器和生成式

#######生成式

生成式就是产生一个迭代器的表达式。通常可以将迭代器看成一种容器，生成器用来生成迭代器的。对生成器的取值都是从上次的取值的下一个开始取，而非从头开始。生成器 = ( 生成式 )，生成式的前后都能修改。

list1 = (x for x in range(10))
print(list1,type(list1))
print(next(list1))
print(next(list1))

result:
<generator object <genexpr> at 0x0060BC30> <class 'generator'>
0
1

生成器和迭代器都是通过next取出里面的数，也可以遍历取数
通过将生成式产生的迭代器转换成了一个列表(列表表达式)

list2 = [x for x in range(10)]

将生成器转换成字典。注意:容器类型的元素是元祖，且每个元组的只有2个元素。看这个例子

dict1 = dict((x,x**2) for x in range(10))
print(dict1,type(dict1))
#交换字典中key和value的值
dict2 = dict((value,key) for key,value in dict1.items())
print(dict2)

result:
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81} <class 'dict'>
{0: 0, 1: 1, 4: 2, 9: 3, 16: 4, 25: 5, 36: 6, 49: 7, 64: 8, 81: 9}

生成器

只要含有yield关键字的函数，这种函数会变成生成器。

有yield的对象，在调用函数的时候不再获取返回值。而是产生一个生成器对象，生成器对象保留的是函数体
使用next获取生成器中的数据的时候，才会执行函数体，执行到yield停止，并将yield后面的结果作为生成的数据返回。同时记录结束的位置，下次调用时next
的时候，从上一次yield语句的下一句开始执行。
案例

print('------------------')
def func2():
    for x in range(10):
        yield x
        print('=========')
generator2 = func2()
print(next(generator2))
print(next(generator2))
print(next(generator2))

result:
------------------
0
=========
1
=========
2

案例2(fibonacci序列)

def fibonacci():
    f1 = 1
    f2 = 1
    while True:
        yield  f1+f2
        f1,f2 = f2,f1+f2
fe =fibonacci()

迭代器

生成器和生成式产生的对象就是迭代器(iter)，用法 iter(可迭代的对象) 转换成迭代器对象。迭代器对象也是通过next和遍历获取

iter1 =iter([1,2,3,4,5,6,7,8])
print(iter1,type(iter1))
print(next(iter1))
print(next(iter1))

result:
<list_iterator object at 0x02664EB0> <class 'list_iterator'>
1
2

文件

通过文件能够数据持久化、本地化使用文件保存数据(数据库文件、txt、json、plist、xml、二进制文件(图片，音频，视频))

打开文件

open(文件地址，打开方式，encoding=编码方式)

文件地址：绝对路径和相对路径
相对路径：./相对路径相对当前文件所在目录，../当前文件所在目录的上一级目录
绝对路径：文件的实际路径(通常不使用)
文件打开方式

打开方式	内容
r	文本(str)形式的读
rb	文本的二进制形式的读
w	写操作，写文本覆盖原文件
wb	写二进制数据覆盖原文件
a	写内容，追加到原内容末尾

编码方式：以文本的方式读和写需要设置编码
open函数的返回值是被打开的文件对象

f = open('./1.txt',encoding='utf-8')

关闭文件

文件.close()

文件操作

读操作(注意每读一次数据，文件的读取指针位置发生变化)
f.read()读取文件的全部内容
f.readline()读取文件的一行内容

#将文本对象f中的全部数据一行一行的打印出来
content = f.readline()
print(content)
while content:
    print(content)
    content = f.readline()
f.close()

写操作
f.write()
w -- 对应的写是完全覆盖原文件内容
a -- 对应的写是追加内容到原文件内容末尾
当以读的形式打开不存在的文件就会返回FileNotFoundError；若以写的方式打开一个不存在的文件，就会创建一个新文件
案例(统计一个模块运行的次数)

if __name__ == '__main__':
    f = open('./2.txt','r',encoding='utf-8')
    count = int(f.read())
    count += 1
    f.close()
    f = open('./2.txt', 'w', encoding='utf-8')
    f.write(str(count))
    f.close()