Python 객체지향 고급 장

아래 편집자는 Python Advanced_객체 지향 발전에 대한 간략한 토론에 관한 기사를 가져올 것입니다. 편집자님이 꽤 좋다고 생각하셔서 지금 공유하고 모두에게 참고용으로 드리도록 하겠습니다. 에디터를 따라가며 살펴보겠습니다.

객체지향 상속, 다형성, 캡슐화의 세 가지 주요 기능을 배웠습니다. 오늘 우리는 객체 지향, 리플렉션 및 일부 클래스의 내장 기능에 대한 고급 콘텐츠를 살펴봅니다.

1. isinstance 및 issubclass

class Foo:
 pass

class Son(Foo):
 pass

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

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

2. Reflection

Reflection의 개념은 1982년 Smith가 처음 제안했는데, 이는 주로 프로그램이 액세스하고 감지하고 자신의 상태나 행동에 맞게 용량을 수정합니다(성찰). 이 개념의 도입으로 컴퓨터 과학 분야에서 응용 반사율에 대한 연구가 빠르게 촉발되었습니다. 프로그래밍 언어 설계 분야에서 처음 채택되었으며 Lisp 및 객체 지향 분야에서 성과를 거두었습니다.

Python 객체 지향의 반사: 문자열 형태로 객체 관련 속성을 조작합니다. Python의 모든 것은 객체입니다(리플렉션을 사용할 수 있습니다)

리플렉션을 구현할 수 있는 네 가지 함수: hasattr, getattr, setattr, delattr

다음 메서드는 클래스와 객체에 적용됩니다(모든 것이 객체이므로 클래스 자체 객체)

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

 def func(self):
  print(123)

egg = Foo()
#常用：
#hasattr
#getattr
# print(hasattr(egg,'name'))
print(getattr(egg,'name'))
if hasattr(egg,'func'): #返回bool
 Foo_func = getattr(egg,'func') #如果存在这个方法或者属性，就返回属性值或者方法的内存地址
         #如果不存在，报错，因此要配合hasattr使用
 Foo_func()
#不常用：
#setattr
# setattr(egg,'sex','属性值')
# print(egg.sex)
# def show_name(self):
#  print(self.name + ' sb')
# setattr(egg,'sh_name',show_name)
# egg.sh_name(egg)
# show_name(egg)
# egg.sh_name()

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


# print(egg.name)
# egg.func()
# print(egg.__dict__)


#反射
#可以用字符串的方式去访问对象的属性、调用对象的方法
反射举例1

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()
#类也是对象

반영 예시 2

import my_module
# print(hasattr(my_module,'test'))
# # func_test = getattr(my_module,'test')
# # func_test()
# getattr(my_module,'test')()
#import其他模块应用反射

from my_module import test


def demo1():
 print('demo1')

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

#对象
#类
#模块 ： 本模块和导入的模块

def register():
 print('register')

def login():
 pass

def show_shoppinglst():
 pass
#
print('注册，登录')
ret = input('欢迎，请输入您要做的操作： ')
import sys
print(sys.modules)
# my_module = sys.modules[__name__]
# if hasattr(my_module,ret):
#  getattr(my_module,ret)()
if ret == '注册':
 register()
elif ret == '登录':
 login()
elif ret == 'shopping':
 show_shoppinglst()
反射举例4

def test():
 print('test')

3. 클래스 내장 함수

1, __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

2, __del__

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

f = Foo()
print(123)
print(123)
print(123)
#析构方法，当对象在内存中被释放时，自动触发执行。
#注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

3, 아이템 시리즈

__getitem____setitem____delitem__

class Foo:
 def __init__(self):
  self.name = 'egon'
  self.age = 73
  
 def __getitem__(self, item):
  return self.__dict__[item]

 def __setitem__(self, key, value):
  # print(key,value)
  self.__dict__[key] = value

 def __delitem__(self, key):
  del self.__dict__[key]
f = Foo()
print(f['name'])
print(f['age'])
f['name'] = 'alex'
# del f['name']
print(f.name)
f1 = Foo()
print(f == f1)

4、__new__

# class A:
#  def __init__(self): #有一个方法在帮你创造self
#   print('in init function')
#   self.x = 1
#
#  def __new__(cls, *args, **kwargs):
#   print('in new function')
#   return object.__new__(A, *args, **kwargs)
# a = A()
# b = A()
# c = A()
# d = A()
# print(a,b,c,d)

#单例模式
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()
three = Singleton()
go = Singleton()
print(one,two)

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

5、 __call_

class Foo:
 def __init__(self):
  pass
 def __call__(self, *args, **kwargs):
  print('__call__')

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

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))

class A:
 def __init__(self):
  self.a = 1
  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 == b)

#__eq__控制着==的结果

위 내용은 Python 객체지향 고급 장의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!