反射，面向对象进阶

àì夳堔傛蜴生んèń 2021-12-13 01:27 286阅读 0赞

### 反射： ###

反射：是用字符串形式的名字取操作变量，没有存在安全隐患问题

如eval("print(name)") 是以字符串形式去执行代码，

参考博客：www.cnblogs.com/Eva-J/articles/7351812.html

\# hashattr    getattr    delattr   setattr

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Teacher:
        dic = {
         "显示老师信息":"show_teacher","显示学生信息":"show_student"}
        def show_teacher(self):
            print("xinxi wwwww")
        def show_student(self):
            print("xueshengxinxi ")
    
    tel = Teacher()
    for i in tel.dic:
        print(i)
    tt = input("输入你的需求：")
    if hasattr(tel,Teacher.dic[tt]):   #如果有这个key
        fun = getattr(tel,Teacher.dic[tt])    #返回个这个key对着的值 对应的方法
        fun()  #  对这个方法直接调用

最主要经常用的是hashattr   getattr  这两个一般配合使用

反射的几种情况：

1  反射对象属性

a.name = 'alex'   -------->ret = getattr(a,'name')    print（ret）  \#返回alex

2 类中的一个方法

class A:
        def  func(self):
            print('in  func')
    
    a = A()
    
    如a.func（）  可以写成
     ret = getattr(a,'func')  ------->ret() 调用

3模块的反射：

如 import my  
print（getattr(my,'day')）   day是my模块中的一个属性

4反射自己模块中的变量：   这依赖于sys模块

print(getattr(sys.modules\[\_\_name\_\_\],'变量名'))

setattr 设置修改一个变量

delattr 删除 delattr(A,'name') a 是一个对象 A是一个类

### 方法： ###

isinstance（obj，cls）检查obj是否是类cls的对象

issubclass(sub,super) 判断子类sub是不是父类super的子类

类里面的内置方法：

\_\_init\_\_ :这是比较常用的

\_\_str\_\_: 方法

class A:
        pass
    a = A()
    print(a)     返回一个内存地址
    
    当A类中没有__str__方法时回去找object父类中的__str__方法
     object里的__str__ 一旦被调用返回这个方法的对象的内存地址

class A:
        def __str__(self):
            return 'A is object' 
    a = A()
    print(a)     #返回'A is object
     若A类自己有__str__ 方法，这返回A类中定义的__str__方法
    每当打印一个对象时，其实就是调用了a.__str__

\_\_repr\_\_  方法：

相当于调用repr() 方法    返回原型

name = '1'
    print(name)   #返回1
    
    print(repr(name))   #返回 '1'

调用\_\_repr\_\_

repr是 str的备胎   reper()      %r

实际上是内部调用了obj.\_\_str\_\_方法，如果str方法有，那么他返回的必定是一个字符串  
\# 如果没有\_\_str\_\_方法，会先找本类中的\_\_repr\_\_方法，再没有再找父类中的\_\_str\_\_。  
\# repr(),只会找\_\_repr\_\_,如果没有找父类的

\_\_del\_\_  析构方法 ，如用在文件的关闭中

class A:  
\# def \_\_del\_\_(self): \# 析构函数: 在删除一个对象之前进行一些收尾工作  
\# self.f.close()  
\# a = A()  
\# a.f = open() \# 打开文件 第一 在操作系统中打开了一个文件 拿到了文件操作符存在了内存中  
\# del a \# a.f 拿到了文件操作符消失在了内存中

\_\_call\_\_ 方法

一个对象a   a()   这就相当于执行了\_\_call\_\_方法

\_\_len\_\_ 方法

class Class:
        def __init__(self,name):
            self.name = name
            self.student = []
        def __len__(self):
            return len(self.student)
    
    a = Class('linux')
    a.student.append('xiao')
    print(len(a.student))

item系列方法：类似于字典的调用

\_\_getitem\_\_   查看 如f\[‘key’\]  可以以这种方式查看其值

lass Foo:
        def __init__(self,name,age,sex):
            self.name = name
            self.age = age
            self.sex = sex
        def __getitem__(self,item):
            if hasattr(self,item):
                return self.__dict__[item]
    
    f = Foo('ego',38,'nan')
    print(f['name'])     #原先是f.name这样调用现在可以这样调用了

\_\_seritem\_\_  :进行修改  如f\['host'\] = 'xiao'    \#调用setitem设定

class Foo:
        def __init__(self,name,age,sex):
            self.name = name
            self.age = age
            self.sex = sex
        def __getitem__(self,item):
            if hasattr(self,item):
                return self.__dict__[item]
        #设计修改属性
        def __setitem__(self,key,value):
            self.__dict__[key] = value
    
    f = Foo('ego',38,'nan')
    print(f['name'])     #原先是f.name这样调用现在可以这样调用了
    f['host'] = 'xiao'    #调用setitem设定
    print(f.host,f['host'])  # 两种调用方式
    print(f.__dict__)   #{
         'name': 'ego', 'age': 38, 'sex': 'nan', 'host': 'xiao'}
    
    f.__dict__  查看多了host：xiao  这项

\_\_delitem\_\_  删除  del  f\['host'\]   以这样方式删除     原del  f.host

del  __delitem__(self,key):
        del  self.__dict__[key]

**\_\_new\_\_ 方法 构造方法**

先进行构造返回*'in new ， *

object.__new__(cls)   是构造一个类 A ----》返回  in  init

class A:
        def __init__(self):
            print('in init ')
        def __new__(cls):
            print('in new')
            return object.__new__(cls)
    a = A()    #返回in new' 构造

与new匹合使用的是单列模式：

单列模式：是指一个类始终只有一个对象，也就是所有的对象都指向一个内存地址空间

是一个对象

\#当你第一次实例化这个类的时候，就常见一个实例化对象，当你之后再来实例化时候，就用之前创建的对象

#单例模式
    class A:
        __li = False
        def __init__(self,name,age):
            self.name = name
            self.age = age
        def __new__(cls,*args,**kwargs):
            if cls.__li:
                return cls.__li
            cls.__li = object.__new__(cls)
            return cls.__li
    a = A('XIAO',20)
    print(a)
    b = A('long',20)    #这两个是一个对象，内存地址一样
    print(b)

**\_\_eq\_\_方法  等于  ==**

class A:
        def funx(self):
            print('ss')
    
    a = A()
    b = A()
    print(a == b)    #因为ab指向两个内存地址空间所以返回False

现在通过\_\_eq\_\_ 方法自己定义他能的等值

class A:
        def __init__(self,name):
            self.name = name
        def __eq__(self,other):
            if self.name == other.name:
                return True
            return False
    
    a = A('xiao')
    b = A('xiao')
    print(a == b)    #因为ab指向比较的是name的值所以返回True

**\_\_hash\_\_ 方法  可hash的都有一个\_\_hash\_\_ 方法**

class A:
        def __init__(self,name,sex):
            self.name = name
            self.sex = sex
        def __hash__(self):
            return hash(self.name + self.sex)
    
    a = A('egg','nv')
    b = A('egg','nv')
    hash(a) 
    hash(b)  # 此时ab 的hash值是一样的  按自己的定义hash
    
    这样加上__eq__方法也可以通过hash值进行比较

from  collections  import  namedtuple: 有名字的元组，按名字取值
    card = namedtuple('card',['rank','suit'])   #相当于定义的一个类
    c1 = card(5,'红桃')    #想一个实例化
    print(c1)   #
    print(c1.suit)

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

牌
    import json
    from collections import namedtuple
    Card = namedtuple('Card',['rank','suit'])   # rank 牌面的大小 suit牌面的花色
    # class FranchDeck:
    #     ranks = [str(n) for n in range(2,11)] + list('JQKA')   # 2-A
    #     suits = ['红心','方板','梅花','黑桃']
    #
    #     def __init__(self):
    #         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
    #                                         for suit in FranchDeck.suits]
    #
    #     def __len__(self):
    #         return len(self._cards)
    #
    #     def __getitem__(self, item):
    #         return self._cards[item]
    #
    #     def __setitem__(self, key, value):
    #         self._cards[key] = value
    #
    #     def __str__(self):
    #         return json.dumps(self._cards,ensure_ascii=False)
    
    # deck = FranchDeck()
    # print(deck[10])
    # from random import choice
    # print(choice(deck))
    # # print(choice(deck))
    # from random import shuffle
    # shuffle(deck)
    # print(deck[10])
    # print(deck)
    # print(deck[:5])

牌

\#一个类有100个对象，有名字和性别相同，年龄不同  
去重（set）  
set(a,b) 依赖于\_\_eq\_\_ \_\_hash\_\_ 这两个方法

**hashlib模块：**  
摘要算法：如两个字符串比较，只要有其中一个不一样就返回false

import hashlib \# 提供摘要算法的模块，常见算法md5  
md5 = hashlib.md5()  
md5.update(b'alex3714') \#注  意字符类型 b  
print(md5.hexdigest())    \#通过hexdigest调用查看

\#不管算法多么不同，摘要的功能始终不变  
\#对相同的字符串使用同一算法进行摘要，得到的值总是不变的  
\#使用不同算法对相同字符串进行摘要，得到的值应该不同  
\#不管使用什么算法，使用hashlib的方式不变

用途：

1一般做密码的密码存储  
2文件的一致性验证  
　　\#在下载的时候，检查我们下载的文件和服务器上的文件是否一致  
　　\#两个文件，检查这两文件是否相同 ，如用于集群的概念

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#用户登录
    文件中
    long|aee949757a2e698417463d47acac93df|admin
    xiao|3d9471f56f436d465c7feecd2113a82b|admin
    
    import hashlib
    
    user = input("输入用户：")
    pwd = input("输入密码：")
    with open('f1') as f:
        for line in f:
            usr,passwd,role = line.split('|')
            md5 = hashlib.md5()
            md5.update(bytes(pwd,encoding='utf-8'))
            md5_pwd = md5.hexdigest()
            if user == usr and md5_pwd == passwd:
                print("成功")

\#用户登录

加盐  提高密码安全
    import hashlib   # 提供摘要算法的模块
    # md5 = hashlib.md5(bytes('盐',encoding='utf-8'))
    # # md5 = hashlib.md5()
    # md5.update(b'123456')
    # print(md5.hexdigest())

对一个文件进行摘要算法是可以进行对个分开的update

import hashlib
    
    md5 = hashlib.md5()
    md5.update(b'alex')
    md5.update(b'3714')
    print(md5.hexdigest())   一次返回

**configparser  模块**

是一个处理配置文件的模块，但它对配置文件的格式有严格要求，所以应用较少 有一定局限性

创建一个配置文件
    import configparser
    config = configparser.ConfigParser()
    config['default'] = {
        'ServerAliveInterval': '45',       #创建default配置段
                         'Compression': 'yes',
                         'CompressionLevel': '9',
                         'ForwardX11': 'yes'}
    config['bitbucket.org'] = {
        'User':'hg'}
    config['topsecret.server.com'] = {
        'Host Port':'50022','ForwardX11':'no'}
    with open('ff.ini','w') as f:
        config.write(f)

配置文件格式
    
    [default]
    serveraliveinterval = 45
    compression = yes
    compressionlevel = 9
    forwardx11 = yes
    
    [bitbucket.org]
    user = hg
    
    [topsecret.server.com]
    host port = 50022
    forwardx11 = no

查找操作：

import configparser
    config = configparser.ConfigParser()
    config.read('ff.ini')      #读取一个文件
    # 显示配置文件中的配置段  ,默认DEFAULT 配置段是不会显示出来的
    print(config.sections())
    #判断 该配置段是否在配置文件中
    print('bitbucket.org' in config)    # 返回 Turn
    
    # 显示配置段中key的对应值
    print(config['bitbucket.org']['user'])
    #也可以通过get去获取
    print(config.get('bitbucket.org','user'))
    #循环显示bitbucket.org配置段下的所有key，记住默认都会讲dafault配置段下的key也显示出来
    # for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    #     print(key)
    
    print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对  默认也会同时把DEFAULT 配置段在的也显示出来

增删改操作

# import configparser
    # config = configparser.ConfigParser()
    # config.read('example.ini')   # 先读这个文件
    # config.add_section('yuan')   # 增加section   增加一个配置段
    # config.remove_section('bitbucket.org')   # 删除一个section  删除一个配置段
    # config.remove_option('topsecret.server.com',"forwardx11")  # 删除一个配置项
    
    #到时候进行配置文件重命名
    # config.set('yuan','k2','22222')      #给yuan添加有个key为k2  值为22222
    # f = open('new2.ini', "w")    # 需要打开一个文件
    # config.write(f) # 写进文件  
    # f.close()

loging模块：日志

日志1 用来记录用户的行为 ， 2 可以设定显示的报警级别信息，注意它不能自己主动发现错误

第一中方式：

import logging
    
    file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
    logging.basicConfig(level=logging.DEBUG,       # 输出debug以上的信息内容
                        format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s -  %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S ',    #时间的格式
                        filename='test.log',        #把日志写到文件中
                        filemode='w')
    
    logging.debug('debug message')       # 低级别的 # 排错信息
    logging.info('info message')            # 正常信息
    logging.warning('cuowu jinggao')      # 警告信息
    logging.error('error message')          # 错误信息
    logging.critical('critical message') # 高级别的 # 严重错误信息

日志输出

2019-06-26 17:23:34  - 6-26.py[line:10] - DEBUG -  debug message
    2019-06-26 17:23:34  - 6-26.py[line:11] - INFO -  info message
    2019-06-26 17:23:34  - 6-26.py[line:12] - WARNING -  cuowu jinggao
    2019-06-26 17:23:34  - 6-26.py[line:13] - ERROR -  error message
    2019-06-26 17:23:34  - 6-26.py[line:14] - CRITICAL -  critical message

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：
    
    filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
    filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
    format：指定handler使用的日志显示格式。
    datefmt：指定日期时间格式。
    level：设置rootlogger（后边会讲解具体概念）的日志级别
    stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
    
    format参数中可能用到的格式化串：
    %(name)s Logger的名字
    %(levelno)s 数字形式的日志级别
    %(levelname)s 文本形式的日志级别
    %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
    %(filename)s 调用日志输出函数的模块的文件名
    %(module)s 调用日志输出函数的模块名
    %(funcName)s 调用日志输出函数的函数名
    %(lineno)d 调用日志输出函数的语句所在的代码行
    %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
    %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
    %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
    %(thread)d 线程ID。可能没有
    %(threadName)s 线程名。可能没有
    %(process)d 进程ID。可能没有
    %(message)s用户输出的消息

配置参数

注意

1 这个方式不能解决中文乱码的问题  
2 不能同时网文件和屏幕上输出

第二种设定方式： 创建log对象

1\#支持中文  
2 既可以写入文件，也可以在屏幕显示

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import logging
    logger = logging.getLogger()      #创建log对象
    fh = logging.FileHandler('log.log',encoding='utf-8')       #创建个文件操作对象
    #文件日志格式：
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # 文件操作符 和 格式关联
    fh.setFormatter(formatter)
    #log对象与文件关联
    logger.addHandle(fh）
    #打印
    logging.debug('debug message')       # 低级别的 # 排错信息
    logging.info('info message')            # 正常信息
    logging.warning('警告错误')      # 警告信息
    logging.error('error message')          # 错误信息
    logging.critical('critical message') # 高级别的 # 严重错误信息

输入到文件

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

sh = logging.StreamHandler()    # 创建一个屏幕控制对象
    #格式
    formatter2 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s [line:%(lineno)d] : %(message)s')
    #屏幕操作对象与格式关联
    sh.setFormatter(formatter2)
    #log 对象与屏幕关联：
    logger.addHandle(sh)
    
    打印

输出到屏幕

参考博客

https://www.cnblogs.com/Eva-j/articles/7228075.html\#\_label13

转载于:https://www.cnblogs.com/huxl1/p/11062181.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211210/22b11232a4fd44b7a9fe60586f1c61bd.png