面向对象进阶
一、关于面向对象的两个内置函数
isinstance 判断类与对象的关系 isinstance(obj,cls)检查obj是否是类 cls 的对象，返回值是bool值
issubclass 判断类与类的关系 issubclass(sub, super)检查sub类是否是 super 类的派生类，返回值是bool值
class A:
pass
class B(A):
pass
a = A()
print(isinstance(a,A))
print(issubclass(B,A))
print(issubclass(A,B))
>>>
True
True
False关于类的内置函数
二、反射
什么是反射？
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的
提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
ps：
eval 的功能和反射有点类似，但是 eval 在操作字符串时有很大的安全隐患，反射没有安全隐患。
四个可以实现自省的函数
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
1、getattr(object, name[,default])
获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，
可以在后面添加一对括号。
class A:
def func(self):
print('in func')
a = A()
a.name = 'alex'
a.age = 63
ret = getattr(a,'name') # 通过变量名的字符串形式取到的值
print(ret)
print(a.__dict__)
变量名 = input('>>>') # func
print(getattr(a,变量名))
print(a.__dict__[变量名])
》》》
alex
{'name': 'alex', 'age': 63}
>>>age
63
63反射对象的属性
class A:
def func(self):
print('in func')
a = A()
a.func()
ret = getattr(a,'func')
print(ret) #不加括号只能打印一个内存地址
ret()
》》》
in func
<bound method A.func of <__main__.A object at 0x00000250C461E668>>
in func反射对象的方法
class A:
price = 20
@classmethod
def func(cls):
print('in func')
print(getattr(A,'price'))
》》》
20反射类的属性
#需要使用到装饰器 classmethod staticmethod
class A:
price = 20
@classmethod
def func(cls):
print('in func')
if hasattr(A,'func'):
getattr(A,'func')()
》》》
in func反射类的方法
#新建一个my.py
#内容
day = 'Monday' # 周一
def wahaha():
print('wahahaha')
class C:
pass
#在另一个py文件里运行
import my
print(my.day)
print(getattr(my,'day'))
》》》
Monday
Monday反射模块的属性
#新建一个my.py
#内容
day = 'Monday' # 周一
def wahaha():
print('wahahaha')
class C:
pass
#在另一个py文件里运行
getattr(my,'wahaha')()
》》》
wahahaha反射模块的方法
#新建一个my.py
#内容
day = 'Monday' # 周一
def wahaha():
print('wahahaha')
class C:
pass
#在另一个py文件中运行
import my
print(getattr(my,'C')())
》》》
<my.C object at 0x0000029F28E9E080>反射模块里的类
# time
# asctime
import time
print(getattr(time,'time')())
print(getattr(time,'asctime')())
》》》
1516608195.0811734
Mon Jan 22 16:03:15 2018内置模块也能反射
def qqxing():
print('qqxing')
year = 2018
import sys
print(sys.modules['__main__'].year)
print(getattr(sys.modules['__main__'],'year'))
》》》
2018
2018反射自己模块中的变量
def qqxing():
print('qqxing')
year = 2018
import sys
getattr(sys.modules['__main__'],'qqxing')()
变量名 = input('>>>')
print(getattr(sys.modules[__name__],变量名))
》》》
qqxing
>>>year
2018反射自己模块中的函数
import time
print(time.strftime('%Y-%m-%d %H:%M:S'))
print(getattr(time,'strftime')('%Y-%m-%d %H:%M:S'))
》》》
2018-01-22 16:08:S
2018-01-22 16:08:S要反射的函数可以有参数
hasattr(object, name)
判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
需要注意的是name要用括号括起来
class A:
name = 'xiaoming'
def run(self):
return 'gogogo'
a = A()
print(a.run())
print(hasattr(a,'name')) #判断对象是否有 name 属性
print(hasattr(a,'run')) #判断对象是否有 run 方法
print(hasattr(A,'run')) #判断类是否有 run 属性
print(hasattr(A,'rn'))
》》》
gogogo
True
True
True
False 3、setattr(object, name, values)
给对象的属性赋值，若属性不存在，先创建再赋值。
class A:
pass
a = A()
setattr(a,'name','nezha')
setattr(A,'name','alex')
print(A.name)
print(a.name) 4、delattr(object, name)
删除一个变量，删除指定对象的指定名称的属性，和setattr函数作用相反，当属性不存在的时候，会报错，不能删除对象的方法。
class A:
pass
a = A()
setattr(a,'name','nezha')
setattr(A,'name','alex')
delattr(a,'name')
print(a.name)
delattr(A,'name')
print(a.name)
》》》
alex
Traceback (most recent call last):
File "D:/Python学习/Python/学习资料/学习视频/day27/2.反射.py", line 122, in <module>
print(a.name)
AttributeError: 'A' object has no attribute 'name'在删除时，注意作用域。对象的属性里没有可以去找类的属性，但不能去object这个父类找
三、双下方法
内置的类方法 和 内置的函数之间有着千丝万缕的联系
__str__和__repr__
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
#_*_coding:utf-8_*_
format_dict={
'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type
def __repr__(self):
return 'School(%s,%s)' %(self.name,self.addr)
def __str__(self):
return '(%s,%s)' %(self.name,self.addr)
def __format__(self, format_spec):
# if format_spec
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]
return fmt.format(obj=self)
s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)
'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))
class B:
def __str__(self):
return 'str : class B'
def __repr__(self):
return 'repr : class B'
b=B()
print('%s'%b)
print('%r'%b)
%s和%r
# obj.__str__ str(obj)
# obj.__repr__ repr(obj)
class Teacher:
def __init__(self,name,salary):
self.name = name
self.salary = salary
def __str__(self):
return "Teacher's object :%s"%self.name
def __repr__(self):
return str(self.__dict__)
def func(self):
return 'wahaha'
nezha = Teacher('哪吒',250)
print(nezha) # 打印一个对象的时候，就是调用a.__str__
print(repr(nezha))
print('>>> %r'%nezha)
#a.__str__ --> object
# object 里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址
# l = [1,2,3,4,5] # 实例化 实例化了一个列表类的对象
# print(l)
# %s str() 直接打印 实际上都是走的__str__
# %r repr() 实际上都是走的__repr__
# repr 是str的备胎，但str不能做repr的备胎
# print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
# repr(),只会找__repr__,如果没有找父类的
ps：
print调用），而repr()函数得到的字符串通常可以用来重新获得该对象，通常情况下 obj==eval（repr(obj)) 这个等式是成立的。这两个函数接受一个对象作为其参数，返回适当的字符串。
事实上repr()和``做一样的事情，返回一个对象的“官方”字符串表示。其结果绝大多数情况下（不是所有）可以通过求值运算（内建函数eval（)）重新得到该对象。
str()则不同，它生成一个对象的可读性好的字符串表示，结果通常无法用eval（)求值，但适合print输出。
__del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，
所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
def __del__(self):
print('执行我啦')
f1=Foo()
del f1
print('------->')
#输出结果
执行我啦
------->
简单示范__call__
Python中的__call__允许程序员创建可调用的对象（实例），默认情况下， __call__()方法是没有实现的,这意味着大多数实例是不可调用的。然而，如果在类定义中覆盖了这个方法，那么这个类的实例就成为可调用的。
class A:
def __init__(self,name):
self.name = name
def __call__(self):
'''
打印这个对象中的所有属性
:return:
'''
for k in self.__dict__:
print(k,self.__dict__[k])
a = A('alex')() #后面的括号可以直接让__call__(self)函数执行
》》》
name alex__len__
在执行len()时会自动触发内部的__len__方法
class A:
def __init__(self):
self.a = 1
self.b = 2
def __len__(self):
return len(self.__dict__)
a = A()
print(len(a))item系列
__getitem__ __setitem__ __delitem__
类似字典的用法
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
def __delitem__(self, key):
del self.__dict__[key]
f = Foo('wangming',38,'男')
print(f['name'])
f['hobby'] = '男'
print(f.hobby,f['hobby'])
del f.hobby # object 原生支持 __delattr__
del f['hobby'] # 通过自己实现的
print(f.__dict__)
__new__
构造方法 : 创建一个对象
class A:
def __init__(self):
self.x = 1
print('in init function')
def __new__(cls, *args, **kwargs):
print('in new function')
return object.__new__(A, *args, **kwargs)
a = A()
print(a.x)
》》》
in new function
in init function
1
#单例模式
#一个类 始终 只有 一个 实例
#当你第一次实例化这个类的时候 就创建一个实例化的对象
#当你之后再来实例化的时候 就用之前创建的对象
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()
two.a = 3
print(one.a)
# 3
# one和two完全相同,可以用id(), ==, is检测
print(id(one))
# 29097904
print(id(two))
# 29097904
print(one == two)
# True
print(one is two)
单例模式
单例模式__eq__
__eq__ 定义了类的等号(==)行为
可以去重
class A:
def __init__(self):
self.a = 5
self.b = 2
def __eq__(self,obj):
if self.a == obj.a and self.b == obj.b:
return True
a = A()
b = A()
print(a.a)
print(a.b)
print(b.a)
print(b.b)
print(a == b)
》》》
5
2
5
2
True__hash__
摘要算法：密码密文加密
摘要算法只能加密，没有解密功能
# 摘要算法
# import hashlib # 提供摘要算法的模块
# 不管算法多么不同，摘要的功能始终不变
# 对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的
# 使用不同算法对相同的字符串进行摘要，得到的值应该不同
# 不管使用什么算法，hashlib的方式永远不变
# import hashlib # 提供摘要算法的模块
# sha = hashlib.md5()
# sha.update(b'这是密码区')
# print(sha.hexdigest())
# sha 算法 随着 算法复杂程度的增加 摘要的时间成本空间成本都会增加
# 摘要算法
# 密码的密文存储
# 文件的一致性验证
# 在下载的时候 检查我们下载的文件和远程服务器上的文件是否一致
# 两台机器上的两个文件 你想检查这两个文件是否相等
# 用户注册
# 用户 输入用户名
# 用户输入 密码
# 明文的密码进行摘要 拿到一个密文的密码
# 写入文件
# 用户的登录
import hashlib
usr = input('username :')
pwd = input('password : ')
with open('userinfo') as f:
for line in f:
user,passwd,role = line.split('|')
md5 = hashlib.md5()
md5.update(bytes(pwd,encoding='utf-8'))
md5_pwd = md5.hexdigest()
if usr == user and md5_pwd == passwd:
print('登录成功')
# 加盐 提高密码的安全等级
import hashlib # 提供摘要算法的模块
md5 = hashlib.md5(bytes('盐',encoding='utf-8')) #加盐区可以是任意字符
# md5 = hashlib.md5()
md5.update(b'123456')
print(md5.hexdigest())
# 动态加盐 提高密码的安全等级
# 用户名 密码
# 使用用户名的一部分或者 直接使用整个用户名作为盐
import hashlib # 提供摘要算法的模块
md5 = hashlib.md5(bytes('盐',encoding='utf-8')+b'')
# md5 = hashlib.md5()
md5.update(b'123456')
print(md5.hexdigest())
# 文件的一致性校验
# 文件的一致性校验这里不需要加盐
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
