python学习笔记(7)文件的访问与函数式编程

一、文件读写的3中方法

　　1.直接读入

fiel1=open('test.txt')
file2=open('output.txt')
while True:
　　line=file1.readLine()
　　#这里可以进行逻辑处理
　　file2.write('"'+line[:]+'"'+",")
　　if not line:
　　　　break
#记住在文件处理完成的时候，关闭文件
file1.close()
file2.close()

　　读取文件的3种方法：

　　　　read()将文本文件的所有行读取到一个字符串中去。

　　　　readline()是一行一行的读取

　　　　readlines()是将文本文件的所有行读取到一个list中去，文本文件的每一行都是一个list的一个元素。优点：readline()可以在读取的过程中跳过特定的行

　　2.文件的第二种读取方法,文件迭代器，用for循环的方法

file2=open("output.txt","w")#先将要读取的文件打开
for line in open("test.txt"):#文件迭代器
    #这里可以进行逻辑处理
    file2.write('"'+line[:]+'"'+",')

　　3.文件上下文管理器

#打开文件
#用with...open自带关闭文本的功能
with open('somefile.txt','r') as f:#用with把我要做的事都包括进来
    data=f.read()
#loop整个文档
with open('somefile.txt','r') as f:
    for line in f:
    #处理没一行的数据
#写入文本
with open('somefile.txt','w') as f:
    f.write(text1)
    f.write(text2)
    ......

#把要打印的line写入文件中
with open('somefile.txt','w') as f:
    print(line1,file=f)#将值写进file中去
    print(line2,file=f)

二、二进制问价的读写

　　1.python默认读取的都是文本文件。要是想读取二进制文件就需要把刚刚的'r'改成'rb'

f=open('EDG.jpg','rb')
print(f.read())
#简单的说，任何非标准的文本文件。对于py3来说，标准是unicode，需要用二进制读入这个文件，然后再用
#.decode('.....')方法来解码这个二进制文件

I=open('DegangGuo.txt','rb')
#解码
u.f.read().decode('DeyunCode')

　　2.文件和目录操作

　　　　(1)用python内置的os模块直接调用操作系统提供的接口函数　　

import os
os.name
这里通过OS告诉我们操作系统的名字。如果是posix，说明是nix族，如果是nt，就是windows

　　　　(2)环境变量:操作系统中定义的环境变量，全部保存在os.environ这个dict中，可以直接进行相关的查看

os.envirn

　　　　(3)查看删除创建目录;

#当前目录的绝对路径
os.path.abspath('.')

#在某个目录下面创建一个新的目录，首先把目录的完整路径表示出来
os.path.join('/Users/EDC','Pictures')
#在这里得到的是一个字符串，代表了新的文件夹的位置:/Users/EDC/Pictures/

#需要用到mkdir来创建文件夹
os.nkdir('/Users/EDC/Pictures/')

#同理删除一个文件夹
os.rmdir('Users/EDC/Pictures/')

#同样的道理，在拆分路径的时候，也不要直接去拆分字符串，而是要通过os.path.split()函数,这样可以将一个路径拆分为两部分，后一个部分总是最后级别的目录或者文件名：
os.path.split('Users/EDC/Pictures/AJiao.avi')
#('/Users/EDC/Pictures/','AJiao.avi')

#或者通过os.path.splitext()得到文件得扩展名
 os.path.splitext('/Users/EDC/Pictures/','AJiao.avi')
#('/Users/EDC/Pictures/AJiao','avi')

#文件重命名
os.rename('JAV-001.avi','学习资料')
#删除文件
os.remove('学习资料')

　　

三、第三方库的调用

　　1.Shutil库的调用

import shutil
shutil.copyfile('path/to/file','/path/to/other/file')#实现文件的复制

　　2.列出当前目录下的所有目录

[x for x in os.listdir('.') if os.apth.isdir(x)]#如果x是一个文件夹的话，就进行这样的操作
#你会得到一个list文件夹
#如果只想列出所有的py文件
[x for x in os.listdir('.') if os.path.isfile(x) and os.path(x)[1]=='.py']#如果x是一个文件并且x是以.py来结尾的

　　3.序列化和反序列化

什么是序列化？

　　程序运行过程中，所有变量都是在内存中进行操作的，当程序一旦运行完成，结束退出之后，变量占用的内存就被操作系统回收了。因此我们需要讲数据持久化到磁盘中去，下次运行的时候，从磁盘中读取相关的数据。

　　我们将变量从内存中变成可以存储或者可以传输的过程称之为序列化，在python中称之为pickling，在其他语言汇总也称之为serialization、marshalling、flattening等等，说的就是一个意思。反之就称之为反序列化，称之为unpickling，把变量从序列化的对象读取到内存中的过程

　　序列化　　　　　　

import pickle

#此处定义了一个dict字典对象
d=dict(name='思聪',age=29,score=80)
str=pickle.dumps(s)#调用pickle的dumps函数进行序列化的处理，之后返回的是一个string对象
print(str)#可以看看str长得什么样

#定义和创建一个file对象，设定模式为wb，在serialize之后是以二进制的数据来进行相关存储的
f=open('dump.txt','wb')
#将内容序列化到file文件中
pickle.dump(d,f)#将内存中的对象d存放到f文件中的
f.close()#最后关闭文件资源

　　反序列化

就是将刚噶完成的'序列化的码'转换为python看得懂的object对象

import pickle
#从之前dump.txt文件中读取内容
f=open('dump.txt','rb')#设定文件选项模式为rb
d=pickle.load(f)　　#调用load做反序列化的过程
f.close()#关闭文件资源
print(d)
print('name is %s'%d['name'])

　　4.用JSON实现序列化和反序列化

　　JSON类型　　　　　　python类型

　　{}　　　　　　　　　　dict

　　[]　　　　　　　　　　list

　　"string"　　　　　　　　'str'或者u'unicode'

　　1234.56　　　　　　　　int或者float

　　true/false　　　　　　True/False

　　null　　　　　　　　Null

如果想有一个比较结构化的数据想要进行序列化，并且想要别的语言也能够读懂，那么可以用JSON来做

import json
#定义dict字典对象
d1=dict(name='小王',age=20,score=80)
str=json.dumps(d1)#调用json的dumps函数进行json序列化处理
print(str)

#调用json的loads函数进行反序列化处理
d2=json.loads(str)

　　5.高阶函数：可以将别的函数作为参数传入的函数称之为高阶函数

　　　　举个例子：求绝对值的函数式abs()

abs(-10)
10

　　如果只是写abs我们得到的是一个叫做abs的函数

abs　　#直接输出<function abs>,在python中，变量和函数都是一个object，也就是说abs这个函数可以直接复制给另外一个变量

f=abs
f(-9)
9

　　　　(1)高阶函数　　　

def add(x,y,f):
    return f(x)+f(y)

当我么调用add(-5,6,abs)的时候，参数x和y分别接收-5,6和abs:

add(-5,6,abs)
11

　　　　6.匿名函数

　　(1)Lamda函数的语法只包含一个语句，如下：

　　lambda [arg1[,arg2,......argn]]:expressoin

相加的函数
    sum=sambda arg1,arg2:arg1+arg2
    sum(10,20)
    30

实际上就是一个函数;
　　def sum(arg1,arg2):
　　　　return arg1+arg2

　　除了Lambda函数之外，Python还提供了其他的几个辅助工具，让你的函数代码更加的牛逼

　　(2)reduce函数

　　　　python中的reduce函数式一个二元操作函数，他用来讲一个数据集合(列表，元组)中的所有数据进行如下的操作，传给reduce中的函数func()必须是一个二元操作函数，先对集合中第一二个元素进行操作，得到的结果在与第三个数据用func()函数来运算最后得到的一个结果

　　　　顾名思义，reduce函数就是把list给缩成一个值，所以必须用二元的操作函数

from functools import reduce
l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,l))#这里代表着把list中的值一个个放进lambda的x,y中

#这个地方，如果给出了一个初始值，可以放在lsit后面
print(reduce(lambda x,y:x+y,l,10))
#这样x开始的时候就别赋值为10，然后依次

　　(3)map函数：map函数用于每一个可以迭代的项，返回的结果是list。如果有其他可以迭代的参数传递进来，map函数会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到每个元素，并把结果返回给新的list

　　格式：map(func,seqq[,....seq2])

　　python函数式的编程中map()函数都是讲func作用于seq中的每一个元素，并用一个列表给出一个返回值。

　　　　map可以使用任何lambda函数来进行操作，本质是把原来的list根据lambda法则变成另外一个list

l=[1,2,3]
new_list=list(map(lambda i:i+1,l))
print(new_list)

#py3中，外面要套一个list

#我们也可以把两个数组搞成单独的数组
l2=[4,5,6]
new_list=list(map(lambda x,y,l,l2))
print(new_list)

　　(4)filter函数

　　filter()可以对序列做过滤处理，可以用一个自定义的函数来过滤一个序列，把序列的每一项传递到自定义的过滤函数里进行相关的处理，并返回结果做过滤。最终一次性返回过滤后的结果。和map()函数相类似。filter也可以接收一个函数和序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回的是True或者False决定是保留元素还是丢弃

　　语法：filter(func,seq)

l=[100,20,24,50,110]
new=list(filter(lambda x:x<50,l))#py3将整个得到的list转换为list函数，便于打印出来
print(new)

　　7.装饰器：装饰器就是函数的[包装] 

def hello(fn):
    def wrapper():
        print("hello,%s"% fn.__name__)
        fn()
        print("goodby,%s"% fn.__name__)
        return wrapper

@hello
def foo():
    print("i am foo")

foo()

返回结果：hello,foo
　　　　　　i am foo
　　　　　　goodby,foo
你可以看到：
　　(1)函数foo前面有个@hello的注解，hello就是我们前面定义的函数hello
　　(2)在hello函数中，需要一个fn函数的参数(这就用来回调的函数)
　　(3)hello函数汇总返回了一个inner函数wrapper，这个wrapper函数回调了传进来的fn，并在回调前后加了两条语句
　　(4)从本质上讲，用@decorator来修饰某个函数的时候，其实是做了两件事
　　　　@decorator
　　　　def func():
　　　　　　pass
　　　　变成===>func=decorator(func)再简单一点，就是把一个函数传递到林割爱一个函数，然后再调给自己
　　(5)hello(foo)返回了wrapper()函数，所以foo其实变成了wrapper的一个变量，二后面的foo()执行其实变成了wrapper()

　　(6)同理我们可以搞多个decorator：
　　　　　　@decorator_one
　　　　　　@decorator_two
　　　　　　def func():
　　　　　　　　pass
　　　　　　相当于：func=decorator_one(decorator_two(func))

def makeHtmlTag(tag,*args,**kwds):
    def real_decorator(fn):
        css_class=" class='{0}'".format(kwds["css_class"]) 
                 if "css_class" in kwds else ""
        def wrapped(*args,**kwds):
            return "<"+tag+css_class+">"+fn(*args,**kwds)+"</"+tag+">"
        return wrapped
    return real_decorator
@makeHtmlTag(tag ="b",css_class="bold_css")
@makeHtmlTag(tag="i",css_class="italic_css")

def hello():
    return "hello world"
print(hello())

class myDecorator(object):
    def __init__(self,fn):
        print("inside myDecorator.__init__()")
        self.fn=fn
    def __call__(self):
        self.fn()
        print("inside myDecorator.__call__()")
@myDecorator
def aFunction():
    print("inside aFunction()")
print("Finished decorating aFunction()")

aFunction()