python：面向对象进阶

概述1，反射反射：使用字符串类型的名字去 *** 作变量反射就没有安全问题，去 *** 作内存中已经存在的变量 #反射对象中的属性和方法 class A:price=20print(getattr(A,'price'))#反射对象的属性class A:def func(self):print('in func')a =A()a.name ='alex'ret =getattr(a,'name')#通过变量名的字符串形式取到的值print(ret)#反射对象的方法ret =getattr（a,'func'）ret()#反射类的方法：if hasattr(A,'func')):getattr(A,'func')() #反射类的属性 class A：price=20print(getattr(A,'price'))#反射模块的属性 import myprint(getattr(my,'day'))#反射自己模块中的变量import sysprint(getattr(sys.modules['__main__'],'year'))getattr(sys.modules['__main__'],'qqxing')()setattr设置/修改变量class A:passsetattr(A,'name','alex')print(A,name)delattr删除变量delattr(a,'name')2,__str__和__repr__改变对象的字符串显示__str__,__repr__自定制格式化字符串__format__# 双下方法# obj.__str__ str(obj)# obj.__repr__ repr(obj)class Teacher:def __init__(self,name,salary):self.name =nameself.salary =salarydef __str__(self):return "Teacher's object :%s"%self.namedef __repr__(self):return str(self.__dict__)def func(self):return 'wahaha'nezha =Teacher('nazha',250)print(nazha)print(repr(nezha))print('>>> %r'%nezha)#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__,如果没有找父类的class Classes:def __init__(self,name):self.name = nameself.student = []def __len__(self):return len(self.student)def __str__(self):return 'classes'py_s9= Classes('python全栈9期')py_s9.student.append('二哥')py_s9.student.append('泰哥')print(len(py_s9))print(py_s9)#__del__class A:def __del__(self): # 析构函数: 在删除一个对象之前进行一些收尾工作self.f.close()a = A()a.f = open() # 打开文件 第一 在 *** 作系统中打开了一个文件 拿到了文件 *** 作符存在了内存中del a # a.f 拿到了文件 *** 作符消失在了内存中del a # del 既执行了这个方法，又删除了变量# __call__#对象后面加括号，触发执行。#注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()class A:def __init__(self,name):self.name = namedef __call__(self):'''打印这个对象中的所有属性:return:'''for k in self.__dict__:print(k,self.__dict__[k])a = A('alex')() 3,item系列 __getitem____setitem____delitem__class Foo:def __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sexdef __getitem__(self, item):if hasattr(self,item):return self.__dict__[item]def __setitem__(self, key, value):self.__dict__[key] = valuedef __delitem__(self, key):del self.__dict__[key]f = Foo('egon',38,'男')print(f['name'])f['hobby'] = '男'print(f.hobby,f['hobby'])del f.hobby # object 原生支持 __delattr__del f['hobby'] # 通过自己实现的print(f.__dict__)View Code4，__new____init__ 初始化方法__new__ 构造方法 : 创建一个对象class A:def __init__(self):self.x = 1print('in init function')def __new__(cls, *args, **kwargs):print('in new function')return object.__new__(A, *args, **kwargs)a1 = A()a2 = A()a3 = A()print(a1)print(a2)print(a3)单例模式# 一个类 始终 只有 一个 实例# 当你第一次实例化这个类的时候 就创建一个实例化的对象# 当你之后再来实例化的时候 就用之前创建的对象class A:__instance = Falsedef __init__(self,name,age):self.name = nameself.age = agedef __new__(cls, *args, **kwargs):if cls.__instance:return cls.__instancecls.__instance = object.__new__(cls)return cls.__instanceegon = A('egg',38)egon.cloth = '小花袄'nezha = A('nazha',25)print(nezha)print(egon)print(nezha.name)print(egon.name)print(nezha.cloth) 5，__eq__class A:def __init__(self,name):self.name = namedef __eq__(self, other):if self.__dict__ == other.__dict__:return Trueelse:return Falseob1 = A('egon')ob2 = A('egg')print(ob1 == ob2)#'=='默认比较内存地址6，__hash__class A:def __init__(self,name,sex):self.name = nameself.sex = sexdef __hash__(self):return hash(self.name+self.sex)a = A('egon','男')b = A('egon','nv')print(hash(a))print(hash(b))7,hashlib#提供摘要算法import hashlib#提供摘要算法的模块md5 =hashlib.md5()md5.update(b'alex3714')print(md5.hexdigest())1，不管算法多么不同，摘要的功能始终不变2，对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的3，使用不同算法对相同的字符串进行摘要，得到的值应该不同4，不管是用什么算法，hashlib的方式永远不变# 摘要算法# 密码的密文存储# 文件的一致性验证# 在下载的时候 检查我们下载的文件和远程服务器上的文件是否一致# 两台机器上的两个文件 你想检查这两个文件是否相等#用户的登录import hashlibusr = 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())动态加盐#文件一致性的校验import hashlibmd5 = hashlib.md5()md5.update(b'alex')md5.update(b'3714')print(md5 1，反射反射：使用字符串类型的名字去 *** 作变量反射就没有安全问题，去 *** 作内存中已经存在的变量 #反射对象中的属性和方法 =20(getattr(A,))

#反射对象的属性

(==ret =getattr(a,<span >'<span >name<span >')<span >#<span >通过变量名的字符串形式取到的值
<span >print(ret)

#反射对象的方法ret =getattr（a,

#反射类的方法：

hasattr(A,)()

#反射类的属性 

=20(getattr(A,))

#反射模块的属性 

(getattr(my,))#反射自己模块中的变量(getattr(sys.modules[],],)()

setattr设置/修改变量

　　<span >pass<span >

setattr(A,<span >'<span >name<span >',<span >'<span >alex<span >'<span >)

<span >print(A,name)

delattr删除变量

delattr(a,)2,__str__和__repr__

改变对象的字符串显示__str__,__repr__

自定制格式化字符串__format__

== % str(self. =Teacher(,250(>> %r%nezha)l = [1,2,3,4,5] == = Classes((py_s9) (self): == open() a a

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

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

 =          k  self.(k,self.= A()()

 3,item系列

 __getitem__\__setitem__\__delitem__

===</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__getitem__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,item): </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;if</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; hasattr(self,item): </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;return</span> self.<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__dict__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;[item]</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__setitem__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,key,value): self.</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__dict__</span>[key] =<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; value</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__de<a href="https://m.jb51.cc/tag/li/" target="_blank" >li</a>tem__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,key): </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;del</span> self.<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__dict__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;[key]

f = Foo(<span >'<span >egon<span >',38,<span >'<span >男<span >'<span >)
<span >print(f[<span >'<span >name<span >'<span >])
f[<span >'<span >hobby<span >'] = <span >'<span >男<span >'
<span >print(f.hobby,f[<span >'<span >hobby<span >'<span >])
<span >del f.hobby <span >#<span > object 原生支持 delattr
<span >del f[<span >'<span >hobby<span >'] <span >#<span > 通过自己实现的
<span >print(f.<span >dict)

4，__new__

　　__init__ 初始化方法　　__new__  构造方法 : 创建一个对象

= 1 ( (cls,*args,**( object.(A,**a1 =<span > A()
a2 =<span > A()
a3 =<span > A()
<span >print<span >(a1)
<span >print<span >(a2)
<span >print(a3)

单例模式# 一个类 始终 只有 一个 实例# 当你第一次实例化这个类的时候 就创建一个实例化的对象# 当你之后再来实例化的时候 就用之前创建的对象

= == (cls,** cls. cls. = object. cls.egon = A(<span >'<span >egg<span >',38<span >)
egon.cloth = <span >'<span >小花袄<span >'<span >
nezha = A(<span >'<span >nazha<span >',25<span >)
<span >print<span >(nezha)
<span >print<span >(egon)
<span >print<span >(nezha.name)
<span >print<span >(egon.name)
<span >print(nezha.cloth)

5，__eq__ =</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;def</span> <span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__eq__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;(self,other): </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;if</span> self.<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__dict__</span> == other.<span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #800080"&gt;__dict__</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;: </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;return</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; True </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;else</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt;: </span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #0000ff"&gt;return</span><span https://m.jb51.cc/tag/color/" target="_blank" >color</a>: #000000"&gt; False

ob1 = A(<span >'<span >egon<span >'<span >)
ob2 = A(<span >'<span >egg<span >'<span >)
<span >print(ob1 == ob2)

#'=='默认比较内存地址

6，__hash__class A:

7,hashlib#提供摘要算法

hashlibmd5 =(md5.hexdigest())

1，不管算法多么不同，摘要的功能始终不变

2，对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的

3，使用不同算法对相同的字符串进行摘要，得到的值应该不同

4，不管是用什么算法，hashlib的方式永远不变

# 摘要算法# 密码的密文存储# 文件的一致性验证    # 在下载的时候 检查我们下载的文件和远程服务器上的文件是否一致    # 两台机器上的两个文件 你想检查这两个文件是否相等

= input(= input( line = line.split(=== usr == user md5_pwd ==()

#加盐

hashlib md5 = hashlib.md5(bytes(,enCoding=md5.update(b(md5.hexdigest())

#动态加盐

hashlib md5 = hashlib.md5(bytes(,enCoding=)+bmd5.update(b(md5.hexdigest())

#文件一致性的校验

= 总结

以上是内存溢出为你收集整理的python：面向对象进阶全部内容，希望文章能够帮你解决python：面向对象进阶所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/1208001.html