组合的方式完成授权

1、包装是在之前原有的方法的基础上，在做一点改动，这叫包装，就像包装那个append方法

现在我们来做一个open方法

class Open:
    def __init__(self,filename,mode="r",encoding="utf8"):
        self.filename=filename
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):
        print(item)
f1=Open("a.txt","r")
f1.read

C:\python35\python3.exe D:/pyproject/day26/授权.py

read

2、啥都没做，那我们来改动一下

现在就创建了一个a.txt

class Open:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        print(item)
f1=Open("a.txt","w")#f1传给self a.txt传给filename w 传给mode
print(f1.file)
f1.read#此时read并不存在,所以触发了__getattr__

C:\python35\python3.exe D:/pyproject/day26/授权.py

<_io.TextIOWrapper name=‘a.txt‘ mode=‘w‘ encoding=‘utf8‘>

read

3、再改善一下

class Open:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=Open("a.txt","w")#f1传给self a.txt传给filename w 传给mode
print(f1.file)
print(f1.read)#此时read并不存在

C:\python35\python3.exe D:/pyproject/day26/授权.py

<_io.TextIOWrapper name=‘a.txt‘ mode=‘w‘ encoding=‘utf8‘>

<built-in method read of _io.TextIOWrapper object at 0x000000000057EA68>

4、我们看下我们自己的这个read跟系统的open方法的read是不是一个东西

class Open:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=Open("a.txt","w")#f1传给self a.txt传给filename w 传给mode
print(f1.file)
print(f1.read)#获取我们的实例的自己写的read方法，但是实例里面没有，类里面也没有，最终触发了getattr
sys_f=open("b.txt","w+")
print(getattr(sys_f,"read"))#获取系统的open的read方法

C:\python35\python3.exe D:/pyproject/day26/授权.py

<_io.TextIOWrapper name=‘a.txt‘ mode=‘w‘ encoding=‘utf8‘>

<built-in method read of _io.TextIOWrapper object at 0x000000000055EA68>

<built-in method read of _io.TextIOWrapper object at 0x000000000055EB40>

5、现在f.write也能调用了。read你会调用了write也是一样的呀，实例里面没有，类里面也没有，最终触发了getattr，getattr里面是调用的系统的open方法里面的write。所以肯定是可以的

class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","r+")#f1传给self a.txt传给filename w 传给mode
print(f1.read)#获取我们实例自己写的read方法,但是实例里面没有，类里面也没有，最终触发了getattr

print(f1.write)

C:\python35\python3.exe D:/pyproject/day26/授权.py

<built-in method read of _io.TextIOWrapper object at 0x00000000005AEA68>

<built-in method write of _io.TextIOWrapper object at 0x00000000005AEA68>

6、我们执行一下write操作看看能不能写入到文件里面

结果是a.txt里面成功写入了，现在就牛逼了。我们发现我们的实例f1是通过FileHandle这个方法进行write的，并不是系统的open的方法里面的write属性，是经过了getattr中转了一下。

class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","r+")#f1传给self a.txt传给filename w 传给mode
print(f1.read)#获取我们实例自己写的read方法,但是实例里面没有，类里面也没有，最终触发了getattr

f1.write("1111111\n") 

7、我们seek一下，再读一下，到这一步，我们发现，相当于open的所有的方法都传递过来了，都可以正常使用了，上一个是学的包装，继承和派生完成的包装，继承是父类由什么我就继承过来，现在到这里就相当于把open里面的方法继承过来了

class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","r+")#f1传给self a.txt传给filename w 传给mode
f1.write("123456\n")
f1.seek(1)
print(f1.read())

C:\python35\python3.exe D:/pyproject/day26/授权.py

23456

8、上面完成了读操作了，还没有完成写操作呢

实例再调用wirte的方法的时候，先在实例的属性字典里面找，然后去类的属性字典里面找，找不到的话才会触发getattr，所以我们想完成写操作，就在类里面定义一个write的方法就行了，当实例调用的时候会先从类里面找到write就直接执行了

class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def write(self,line):
        print("自己的类里面的定义的write",line)
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","w+")#f1传给self a.txt传给filename w 传给mode
f1.write("123456\n")
f1.seek(1)
print(f1.read())

C:\python35\python3.exe D:/pyproject/day26/授权.py

自己的类里面的定义的write 123456

现在这个write就是调用的自己在类里面定义的那个write方法了，并没有真实的写入到文件中去，而且单纯的打印了一下东西

9、如何实现文件的真正的写操作呢

class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def write(self,line):
        # print("自己的类里面的定义的write",line)
        self.file.write(line)
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","w+")#f1传给self a.txt传给filename w 传给mode
f1.write("123456\n")#把f1传给self，把123456传给line
f1.seek(1)
print(f1.read())

C:\python35\python3.exe D:/pyproject/day26/授权.py

23456

10、给文件内容的前面每行都加上时间

import time
class FileHandle:
    def __init__(self,filename,mode="r",encoding="utf8"):
        # self.filename=filename
        self.file=open(filename,mode,encoding=encoding)#得到的是一个文件句柄
#self.file里面调用了系统的open方法，封装成了自己的open方法，具有系统的open方法的所有特性
        self.mode=mode
        self.encoding=encoding
    def write(self,line):
        # print("自己的类里面的定义的write",line)
        t=time.strftime("%Y-%m-%d %X")#定义时间格式
        self.file.write("%s %s" %(t,line))#进行字符串拼接
    def __getattr__(self, item):#当实例调用的属性不存在的时候触发它
        return getattr(self.file,item)#self.file-->f1.file   item-->"read"
f1=FileHandle("a.txt","w+")#f1传给self a.txt传给filename w 传给mode
f1.write("123456\n")#把f1传给self，把123456传给line
f1.write("234567\n")
f1.write("789123\n")

2018-06-20 22:37:13 123456
2018-06-20 22:37:13 234567
2018-06-20 22:37:13 789123

这种就是组合的方式，给self.file赋予了一个文件描述符，然后利用__getattr__来return所有正常的open里面的所有的属性，如果我们不自己定制write的方法的话，所有的方法就已经是跟系统的方法一样了，但是我们自己定制了write的方法了，给前面加了时间，当然也可以做其他的，比如直接pass，那其他人在调用write的方法的时候就写入不了了

原文地址：https://www.cnblogs.com/gouguoqilinux/p/9215568.html

时间： 2024-11-08 16:17:52

组合的方式完成授权的相关文章

Python进阶-----类组合的方式完成授权

授权:授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能.其它的则保持原样.授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性. import time class FileHandle: def __init__(self,filename,mode = 'r',encoding = 'utf-8'): self.file = open(filename,mode,encoding=encod

应用组合的方式实现继承关系

package com.Summer_0426.cn; /** * @author Summer * 应用实例:应用组合的方式实现继承关系 * 动物类Animal * 方法:心跳 * 动物类Dog * 方法:run */ class Heart{ public void beat(){ System.out.println("心跳"); } } class Dog{ Heart heart = new Heart();//成员变量即初始化对象 public void run(){ Sy

python一中实现组合的方式

方式1:#!/usr/bin/env python#-*- encoding: utf-8 -*- def permutations(iterable, r=None):    # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC    # permutations(range(3)) --> 012 021 102 120 201 210    pool = tuple(iterable)    n = len(p

设计模式-Strategy Strategy将算法封装到类中，通过组合的方式 将具体算法的实现在组合对象中实现

以下代码来源: 设计模式精解-GoF 23种设计模式解析附C++实现源码 //strategy.h #pragma once class Strategy { public: Strategy(); virtual ~Strategy(); virtual void AlgrithmInference() = 0; protected: private: }; class ConcreateStrategyA :public Strategy { public: ConcreateStrateg

python类 包装 授权

"包装"是指对一个已经存在的对象进行系定义加工. 实现授权是包装的一个特性.包装一个类型通常是对已存在的类型进行一些自定义定制,这种做法可以新建,修改,或删除原有产品的某些功能,而其他的保持不变.授权的过程,其实也就是所有的更新功能都交给新类的自定义的某部分功能来处理,但已存在的功能就授权给对象的默认属性. 实现授权的关键点是覆盖__getattr__()方法,在代码中包含一个对getattr()内建函数的调用,调用getattr()得到默认对象的属性,并返回它以便访问或者调用. 用组

Python随心记--类的内置attr属性

class Foo: x = 1 def __init__(self,y): self.y = y def __getattr__(self, item): #如果对象不存在的属性是会触发 print('执行了__gerattr__') def __delattr__(self, item): #删除的时候会触发 print('执行了__delattr__') self.__dict__.pop(item) def __setattr__(self, key, value): #设置属性是会触发

自定义Android组件之组合方式创建密码框组件

Android中所有控件(也称组件)都继承自adnroid.view.View类,android.view.ViewGroup是View类的重要子类,绝大多书的布局类就继承自ViewGroup类. 附上一张基于Android Api21的View和Widget类图 自定义Android组件基本可以从2个入口着手,一是继承Viewe类拿起画笔和画布绘制组件,而是通过继承View的子类和组合已有的组件的方式构造自定义的组件. 本文通过自定义一个PassWordView组件来实现密码能够通过点击点选框

OAuth 第三方登录授权码（authorization code）方式的小例子

假如上面的网站A,可以通过GitHub账号登录: 下面以OAuth其中一种方式,授权码(authorization code)方式为例. 一.第三方登录的原理 所谓第三方登录,实质就是 OAuth 授权. 数据的所有者告诉系统,同意授权第三方应用进入系统,获取数据.系统从而产生一个短期的进入令牌(token),用来代替密码,供第三方应用使用. 用户想要登录 A 网站,A 网站让用户提供第三方网站的数据,证明自己的身份.获取第三方网站的身份数据,就需要 OAuth 授权. 这里利用OAuth au

ASP.NET Core MVC 授权的扩展：自定义 Authorize Attribute 和 IApplicationModelProvide

一.概述 ASP.NET Core MVC 提供了基于角色( Role ).声明( Chaim ) 和策略 ( Policy ) 等的授权方式.在实际应用中,可能采用部门( Department , 本文采用用户组 Group ).职位 ( 可继续沿用 Role ).权限( Permission )的方式进行授权.要达到这个目的,仅仅通过自定义 IAuthorizationPolicyProvider 是不行的.本文通过自定义 IApplicationModelProvide 进行扩展. 二.P