python笔记整理day3

装饰器：遵循开放封闭原则，在不改变原函数的情况下，扩展了函数的的功能

函数名仅仅是个变量，只不过指向定义的函数而已，所以才能通过函数名()调用，如果函数名=xxx
被修改了，那么当在执行函数名()时，调用的就不指向之前的那个函数了
def decorater(fun):
    def wrapper():
        fun()
        print('刷漆')
    return wrapper
@decorater
def house():
    # house=decorater(house)
    print('毛坯房')

house()
装饰器的功能：
1、引入日志  2、函数执行时间统计  3、执行函数前预备处理  4、执行函数后清理功能  5、权限校验等场景  6、缓存
'''
装饰器定义：
def aaa(func):
   def bbb(参数...):
      func()
      ...
    return bbb
装饰：
@装饰器名   原函数=装饰器（原函数）
def 原函数():
   pass
带参数的装饰器
def decorater(func):
    def wrapper(*args,**kwargs):
        func(*args,**kwargs)
        print('刷漆')
        print('铺地板')
    return wrapper
@decorater
def house(name,address,area=40):
    print('{}房子位于{},共计{}平米'.format(name,address,area))
house('平安喜乐','刘屯')
装饰器修饰有返回值的参数
原函数有返回值，装饰器内部也要有返回值
def decorater(func):
    def wrapper(*args,**kwargs):
        r=func(*args,**kwargs)
        print('预计装修费用{}'.format(r))
        print('刷漆')
        print('铺地板')
        return r
    return wrapper

@decorater
def house():
    print('我是一个毛坯房')
    return 300
r=house()
print(r)
print('*'*20)
def outer_check(time):
    print('-------')
    def check_time(action):
        def do_action():
            if time<22:
                return action
            else:
               print('999')
        return do_action
    return  check_time
@outer_check(23)
def play_game():
    print('0000')
print(play_game())
递归函数：如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数
遵循：1、递归需要有出口
     2、每次递归向出口靠近
练习：使用递归实现斐波那契数列：1，1，2，3，5，8，13，21，34


匿名函数：使用lambda关键词能创建小型函数，这个函数称为匿名函数，这种函数省略了def的声明
匿名函数的定义格式：  lambda 参数列表：返回值运算表达式
lambda函数能接收任何数量的参数但只能返回一个表达式的值
r=lambda a:a+1
r(2)
print(r(2))
匿名函数的应用场景：
1、匿名函数作为参数使用
def func1(a,f):
    print('---a')
    r=f(a)
    print(r)
    print('----b')
func1(2,lambda x:x+1)
'''
在python中，函数其实也是一种数据类型，函数对应的数据类型是function，可以把它当作是一种
复杂的数据类型，既然同样都是一种数据类型，我们就可以把它当作数字或者字符串进行处理
高阶函数：一个函数的参数是另一个函数
系统高阶函数：max  min  sorted
'''
list1=[('tom',19),('jerry',20),('rose',12),('cat',23)]
m=max(list1,key=lambda x:x[1])
print(m)
n=min(list1,key=lambda x:x[1])
print(n)
s=sorted(list1,key=lambda x:x[1],reverse=True)
print(s)
# filter的匿名函数要求返回值必须是bool类型，只有bool类型结果为True的才是符合过滤条件的
rr=filter(lambda x:x[1]>=20,list1)
print(list(rr))
# map：用来提取  通过匿名函数指明提取内容，并对内容进行加工处理

ma=map(lambda x:x[0].upper,list1)
print(list(ma))
print('*'*20)

from functools import reduce
# 压缩
r=reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(r)

文件操作：文件上传（日志、图片）
mode:r w rb wb
r、w分别表示读写  只能读写纯文本文件
rb、wb可以读写二进制文件  （视频、图片）
open(file,mode,buffering,encoding)
读文件：
open(path/filename,'rt)返回值：stream(管道)
container=stream.read()  读取管道中内容
注意：如果传递的path/filename有误 则会报错  FileNotFoundError
     如果是图片则不能使用默认的读取方式，默认读取方式rt  mode='rb'
总结：
read()   读取所有内容
readable()  判断文件是否可读
readline()  每次读取一行内容
readlines() 读取所有行保存到列表中
写文件：
stream=open(path/filename,'w')  mode='w'表示写模式
方法：mode='w'
   write(内容):每次都会将原来的内容清空，然后写当前的内容
   writelines(iterable):没有换行的效果，可以手动添加
   fp=open(r'F:\aa.txt','w')
   fp.write('To LuYi:\n')
   s='You are the best！'
   fp.write(s)
   fp.writelines(['You will be sucessful,','you should be confident!\n','fighting'])
   fp.close()
如果mode='a':
    不会将原来文件内容清空，会在文件的结尾处重新追加内容
文件的复制：
    建立两个文件流  一个用来进行读文件  一个用来进行写文件
    with结合open使用，可以帮助我们自动释放资源
# with open('./qq.jpg','rb') as fp:
#     container = fp.read()
# with open(r'F:\p\gi.jpg','wb') as fp1:
#     fp1.write(container)
# print('over')


模块——os模块  系统模块
1、os.path()
2、os.path.dicname(__file__):找到当前文件所在文件夹的路径  绝对地址
3、os.path.join(path,'path2'):将path和path2连接  形成新的地址
import os
with open('./qq.jpg','rb') as fp:
    container = fp.read()
    print(fp.name)
    qie=fp.name
    filename=qie[qie.rfind('\\')+1:]
    # 截取文件名
    path=os.path.dirname(__file__)
    path1=os.path.join(path,filename)
    with open(path1,'wb')as fp1:
        fp1.write(container)
print('-------over')
4、os.path.isabs()判断路径是否是绝对路径  返回bool值
import os
r=os.path.isabs(r'F:\p\gir.jpg')
print(r)
相对路径：
同级别的文件路径查找：直接查找
不同级别的文件路径查找：比自己级别高 ../  先返回上一级在查找
                   比自己级别低  / 找下一级
r=os.path.isabs('../images/girl_jpg')
r=os.path.isabs('images/girl.jpg'
5、os.path.abspath()  通过相对路径获得绝对路径
   os.path.abspath(__file__)获取当前文件的绝对路径
   os.getcwd() 获取当前文件所在文件夹路径
   os.isfile()
   os.isdic()
   os.split()
   os.splitext()
   os.getsize()
import os
# r=os.path.isabs(r'F:\p\gir.jpg')
# print(r)
# ro=os.path.abspath('./qq.jpg')
# print(ro)
ro=os.path.abspath(__file__)
print(ro)
print('*'*20)
path=r'C:\Users\Administrator\PycharmProjects\pythonProject1\python 419\qq.jpg'
result=os.path.split(path)
# 分割文件所在位置与祖先路径

print(result[1])
print(result)
print('---------------')
path2=r'C:\Users\Administrator\PycharmProjects\pythonProject1\python 419\day1.py'
result1=os.path.splitext(path2)
ss=os.getcwd()
print(ss)
print('$$$$$')
# 分割文件与扩展名
print(result1[1])
print(result1)
size=os.path.getsize(path2)
print(size)
# 获取文件的大小，单位是字节
joi=os.path.join(path2,'file','aa.jpg')
print(joi)

'''
os的函数
os.listdir()返回指定目录下的所有的文件和文件夹，保存到列表中
os.mkdir()  创建指定路径下的文件
os.rmdir()  删除指定路径下的空文件
      os.rmdir(r'F:\r')
      print('delete')
os.removedirs()
os.remove() 删除一个文件
os.path.exit()
os.chdir()切换目录
os.getcwd()获取当前文件目录
'''
import os
path=r'F:\q\qqqq'
name_list=os.listdir(path)
print(name_list)
for list in name_list:
    os.remove(os.path.join(path,list))
    print('移除成功')
else:
    os.rmdir(path)
    print('over')


复制文件：
import os

src_path='F:\q'
target_path='F:\p'
src_name_list=os.listdir(src_path)
print(src_name_list)
for src_name in src_name_list:
    pp=os.path.join(src_path,src_name)

    with open(pp,'r') as fp:
        container=fp.read()
        new_src_name=os.path.split(pp)
        print(new_src_name[1])
        qq = os.path.join(target_path, src_name)
        with open(qq,'w')as fp1:
            fp1.write(container)
else:
    print('over')



复制文件和文件夹
import os

src_path='F:\p'
target_path='F:\q'
def copy(src_path,target_path):
    src_path_list=os.listdir(src_path)
    for src_name in src_path_list:
        path=os.path.join(src_path,src_name)
        print(path)
        if os.path.isdir(path):
            new_path=os.path.join(target_path,src_name)
            os.mkdir(new_path)
            copy(path,new_path)
        else:
            with open(path, 'rb') as fp:
                container = fp.read()
                new_src_name = os.path.split(path)
                print(new_src_name[1])
                qq = os.path.join(target_path, src_name)
                with open(qq, 'wb') as fp1:
                    fp1.write(container)
    else:
        print('end-----')
copy(src_path,target_path)


文件总结：
文件操作：
   open()
   mode
   path  绝对路径  相对路径（相对当前路径）
   stream=open(file,mode)
   stream.read()
   stream.write()
   stream.close()
   with open(path,mode) as stream:
os模块：
os.path常用函数
os常用函数：