python之面向对象进阶3

1.isinstace和issubclass

2.staticmethod和classmethod

3.反射（hasattr、getattr、setattr.delattr等四个方法）

4.内置方法

5.logging

6异常处理

7hashlib摘要算法

1.isinstace和issubclass 

isinstace判断一个对象是否是一个类的对象。与type的区别；判断对象类型时一定要用type。

class Foo:
    pass

class Son(Foo):
    pass

s = Son()
#判断一个对象是不是这个类的对象,传两个参数（对象，类）
print(isinstance(s,Son))
print(isinstance(s,Foo))
# print(type(s) is Son)
# print(type(s) is Foo)

issubclass判断一个类是不是另一个类的子类。

class Foo:
    pass

class Son(Foo):
    pass

s = Son()

#判断一个类是不是另一类的子类，传两个参数(子类，父类)
# print(issubclass(Son,Foo))
# print(issubclass(Son,object))
# print(issubclass(Foo,object))
# print(issubclass(int,object))

2.@staticmethod 和@classmthod

@staticmetho（静态方法）　　没有默认参数让类里的方法直接被调用，就像正常函数一样。（可以被类和对象调用，不推荐用对象调）

class Student:
    f = open('student', encoding='utf-8')
    def __init__(self):
        pass

    def func(self):
        pass
    @staticmethod   #静态方法  ： 让类里的方法直接被类调用，就像正常的函数一样
    def show_student_info_static():
        f = open('student', encoding='utf-8')
        for line in f:
            name, sex = line.strip().split(',')
            print(name, sex)
s=Student()
s.show_student_info_static()
print(Student.show_student_info_static)

@classmethod（类方法）          默认参数是cls，可以直接使用类和对象调用，不推荐用对象调。

class Student:
    f = open('student', encoding='utf-8')
    def __init__(self):
        pass

    def func(self):
        pass

    @classmethod   #类方法：默认参数cls，可以直接用类名调用，可以与类属性交互
    def show_student_info_class(cls):
        for line in cls.f:
            name, sex = line.strip().split(',')
            print(name, sex)    

s=Student()
s.show_student_info_class()
print(Student.show_student_info_class)

总结：

#classmethod和staticmethod
#相同：都可以直接被类调用，不需要实例化
#不同:
#类方法必须有一个cls参数表示这个类，可以使用类属性
#静态方法不需要，静态方法不能直接使用

#绑定方法
#非绑定方法

#普通方法  默认有一个self对象传进来，并且只能被对象调用——绑定到对象
#类方法    默认有一个cls传进来表示本类，并且可以被类和对象（不推荐）调用——绑定到类
#静态方法  没有默认参数，并且可以被类和对象（不推荐）调用——非绑定

#classmethod和staticmethod
#相同：都可以直接被类调用，不需要实例化
#不同:
#类方法必须有一个cls参数表示这个类，可以使用类属性
#静态方法不需要，静态方法不能直接使用

#绑定方法
#非绑定方法

#普通方法  默认有一个self对象传进来，并且只能被对象调用——绑定到对象
#类方法    默认有一个cls传进来表示本类，并且可以被类和对象（不推荐）调用——绑定到类
#静态方法  没有默认参数，并且可以被类和对象（不推荐）调用——非绑定

3.反射（常用：hasattr、getattr；不常用：setattr、delattr）（通过字符串的形式来访问对象的属性与调用对象的方法）（应用范围为 对象、类、模块）

hasattr与getattr：

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 73

    def func(self):
        print(123)

egg = Foo()
print(hasattr(egg,'name'))#返回bool
print(getattr(egg,'name'))
if hasattr(egg,'func'):   #返回bool
    Foo_func = getattr(egg,'func')  #如果存在这个方法或者属性，就返回属性值或者方法的内存地址
                                 #如果不存在，报错，因此要配合hasattr使用
    Foo_func()#执行func方法

不常用的setattr与delattr

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 73

    def func(self):
        print(123)

egg = Foo()

def show_name(self):
    print(self.name + ' sb')
setattr(egg,'sh_name',show_name)#新增一个方法
# egg.sh_name(egg)#新增方法调用时要传参数就是对象自己
# show_name(egg)#通过函数调用

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 73

    def func(self):
        print(123)

egg = Foo()
# delattr
delattr(egg,'name')
print(egg.name)

反射的延伸：（类也是对象）

我们一般用hasattr判断是否有这个属性或方法，用getattr方法调用这个属性或者方法
class Foo:
    f = 123 #类变量
    @classmethod#类方法
    def class_method_demo(cls):
        print('class_method_demo')
    @staticmethod#静态方法
    def static_method_demo():
        print('static_method_demo')
if hasattr(Foo,'f'):#类属性
    print(getattr(Foo,'f'))
print(hasattr(Foo,'class_method_demo'))
method = getattr(Foo,'class_method_demo')
method()
print(hasattr(Foo,'static_method_demo'))
method2 = getattr(Foo,'static_method_demo')
method2()
#类也是对象

模块使用反射分为引入模块与本类模块

引入模块：

import my_module
print(hasattr(my_module,'test'))
# func_test = getattr(my_module,'test')
# func_test()
getattr(my_module,'test')()

在本模块中的使用

def demo1():
    print('喜欢你')

import sys
# print(__name__)  #'__main__'
# print(sys.modules)
#'__main__': <module '__main__' from 'D:/Python代码文件存放目录/S6/day26/6反射3.py'>
module_obj =sys.modules[__name__]  #sys.modules['__main__']
# module_obj : <module '__main__' from 'D:/Python代码文件存放目录/S6/day26/6反射3.py'>
# print(module_obj)
print(hasattr(module_obj,'demo1'))
getattr(module_obj,'demo1')()
#在本模块中应用反射                              

4内置方法

（str与repr）

class Foo:
    def __init__(self,name):
        self.name = name
    # def __str__(self):
    #     return '%s obj info in str'%self.name
    def __repr__(self):
        return ' obj info in repr'# f = Foo('egon')
# print(f)
# print('%s'%f)
# print('%r'%f)
# print(repr(f))  # f.__repr__()
# print(str(f))
#当打印一个对象的时候，如果实现了str，打印返回值
#当str没有被实现的时候，就会调用repr方法
#但是当你用字符串格式化的时候 %s和%r会分别去调用__str__和__repr__
#不管是在字符串格式化的时候还是在打印对象的时候，repr方法都可以作为str方法的替补
#但反之不行
#用于友好的表示对象。如果str和repr方法你只能实现一个：先实现repr

del方法

class Foo:
    def __del__(self):
        print('执行我啦')

f = Foo()
print(123)
print(123)
print('..........')
print(123)
print(123)
print(123)

__new__方法

class A:
    def __init__(self):  #在执行__init__方法有一个方法在帮你创造self
        print('in init function')
        self.x = 1

    def __new__(cls, *args, **kwargs):#先执行__new__方法
        print('in new function')
        return object.__new__(A, *args, **kwargs)
a = A()
b = A()
c = A()
d = A()

单例模式

class Singleton:
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance

one = Singleton()
two = Singleton()
print(one,two)
one.name = 'alex'
print(two.name)

__call__方法

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
    def __call__(self, *args, **kwargs):
        print(123)

Foo()()

__len__

class Foo:
    def __len__(self):
        return len(self.__dict__)
    def __hash__(self):
        print('my hash func')
        return hash(self.name)
f = Foo()
print(len(f))
f.name = 'egon'
print(len(f))
print(hash(f))

__hash__与__eq__   set方法依赖__hash__和__eq__这两个内置方法

#留下同样名字和性别的对象
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True

p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))
print(p_lst)
print(set(p_lst))

纸牌游戏

from collections import namedtuple
Card = namedtuple('Card',['rank','suit'])  #每一个card的对象就是一张纸牌

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    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 __call__(self, *args, **kwargs):
        return self._cards

deck = FranchDeck()
print(deck[0])
print(deck[3])
print(deck[2])
print(deck[1])

# from random import shuffle   #shuffle可以打乱顺序
# shuffle(deck)#洗牌
# print(deck())
# shuffle(deck)
# print(deck())#洗牌

5 logging

通过config来配置只能选择一种输出模式

import logging
#config只能写文件里或者打印在屏幕上2个选择一个
# logging.basicConfig(
#     level=logging.DEBUG,
#     format = '%(name)s %(asctime)s [%(lineno)d] -- %(message)s',#需要输出的内容
#     datefmt = '%d/%m/%y %H:%M:%S',#日期格式
#     filename = 'logging_info'#如果出现它那就是要要把内容放在文件里不会打印到屏幕上
# )
# logging.debug("debug")
# logging.info("info")
# logging.warning("出错了")

logger可以输出屏幕和写入文件

# logger对象可以选择打印或者写在文件里
import logging
def my_logger(filename,file=True,stream = True):
    logger = logging.getLogger()
    formatter = logging.Formatter(fmt='%(name)s %(asctime)s [%(lineno)d] --  %(message)s',
                                  datefmt='%d/%m/%y %H:%M:%S')#指定打印的格式和数据
    logger.setLevel(logging.DEBUG)  #指定日志打印的等级
    if file:
        file_handler = logging.FileHandler(filename,encoding='utf-8')#格式
        file_handler.setFormatter(formatter)  # 文件流 文件操作符
        logger.addHandler(file_handler)
    if stream:
        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(formatter) #屏幕流 屏幕操作符
        logger.addHandler(stream_handler)
    return logger

logger = my_logger('logging')
logger.warning("出错了")
logger.debug("debug")

推荐使用logger

6异常处理

架构

try:
    pass
except ValueError:
    pass
except Exception as e:
    print('统筹处理所有错误的措施')
else:
    print("针对这段try中的代码没有异常要特别处理的")
finally:
    print("不管有没有异常都要执行的代码")

7hashlib摘要算法

import hashlib
md5_obj = hashlib.md5('nezha'.encode('utf-8'))#加盐啦
md5_obj.update(''.encode('utf-8'))
print(md5_obj.hexdigest())
md5_obj.update('hello,egon~'.encode('utf-8'))
print(md5_obj.hexdigest())

主要用途：

# 文件校验
#     文件是否被改变
# 登录密码
#     不能解密，但可以“撞库”
#     加盐 hashlib.md5('nezha'.encode('utf-8'))
给文件加密

import hashlib
md5_obj = hashlib.md5()
import os
filesize = os.path.getsize('filename')#需要自己创建一个文件
f = open('filename','rb')
while filesize>0:
    if filesize > 1024:
        content = f.read(1024)
        filesize -= 1024
    else:
        content = f.read(filesize)
        filesize -= filesize
    md5_obj.update(content)
# for line in f:#这是另一个加密的方式
#     md5_obj.update(line.encode('utf-8'))#这两种不同的加密方式得到的结果是一样的
md5_obj.hexdigest()