python之路_面向对象相关知识点
1、方法与函数的区别？
''' class Foo(object): def __init__(self): self.name = 'alex' def func(self): print(self.name) from types import FunctionType,MethodType obj = Foo() print(isinstance(obj.func,FunctionType)) # False print(isinstance(obj.func,MethodType)) # True print(isinstance(Foo.func,FunctionType)) # True print(isinstance(Foo.func,MethodType)) # False 注意： 方法，无需传入self参数；函数，必须手动传入self参数 '''
2、models对象相关查询
''' 例：model.UserInfo为models类 ''' #（1）获取models类所在app名：model.UserInfo._meta.app_label #（2）获取models类的类名小写：model.UserInfo._meta.model_name #（3）获取models类中的字段内容：model.UserInfo._meta.get_field('username') #（4）获models类中字段的verbose_name：model.UserInfo._meta.get_field('username').verbose_name
3、用type创建类的实现
'''type创建TestModelForm类,参数分别为类名，继承类，类中属性'''
meta = type('Meta',(object,),{'model':self.model_class,'fields':'__all__'}) TestModelForm = type('TestModelForm',(ModelForm,),{'Meta':meta}) #等价于 class TestModelForm(ModelForm): class Meta: model = self.model_class fields = "__all__"
4、反向生成url
#示例如下：namespace为名称空间，name为url别名
reverse("namespace:name")
5、instance与type区别
有这样一个错误说法：isinstance用于判断，对象是否是指定类的实例，具体情况见下实例：
class Foo(object): pass class Bar(Foo): pass obj = Bar() print(isinstance(obj,Foo)) #True print(isinstance(obj,Bar)) #True
所以结论是：isinstance用于判断对象是否是指定类或其派生类的实例，如果需要排除派生类的情况，我们就不能用instance进行实例判断，为了实现这种，就需要使用type进行判断了。示例如下：
print(type(obj) == Bar) #True print(type(obj) == Foo) #False
6、面向对象中的反射相关
在django中，配置文件中中间件的配置方式如下，其实配置的就是不同中间模块的路径。我们可能好奇，这样的字符串形式的配置，内部是如何读取到相应模块中的内容的呢？
通过源码我们发现，其主要也是通过反射实现的，见如下实例：
MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ]
有这样一个setting.py文件，配置了某类的路径：
DB_PATH = "db.sqlserver.SqlServerHelper"
获得SqlServerHelper类，并执行其中相关方法：
from settings import DB_PATH def func(): # DB_PATH = "db.mysql.MySQLHelper" module_path,cls_name = DB_PATH.rsplit('.',maxsplit=1) # 以字符串的形式导入模块 import importlib module_obj = importlib.import_module(module_path) # 去模块中导入类 cls = getattr(module_obj,cls_name) # 类实例化 obj = cls() obj.fetchone() if __name__ == '__main__': func()
还有这样一个实例：根据方法名，去实例对象中获得该方法。
class Foo(object): def func(self): pass obj = Foo() name = "func" fc = getattr(obj,name) fc()
7、面向对象封装数据相关
有这样一个应用，我们需要将models对象中相应的部分字段信息传给后端，我们相当的数据类型可能是：[{},{},{}.....]，其中字典中为每个字段的相应信息。这样做没有问题，但是当我们需要的数据不但不含字段的直接信息，还要包含根据字段获得其他间接数据。这样的话，上述方式就比较难做到。此时我们就可以借助面向对象的封装特性，将数据封装到类中，间接数据的获得可以在类中的方法实现，最终只需将实例化的类对象发给后端就可以。具体实例如下：
#封装数据的类 class FilterOption(object): def __init__(self,field_name,multi=False,condition=None,is_choice=False): """ :param field_name: 字段 :param multi: 是否多选 :param condition: 显示数据的筛选条件 :param is_choice: 是否是choice """ self.field_name = field_name self.multi = multi self.is_choice = is_choice self.condition = condition def get_queryset(self,_field): if self.condition: return _field.rel.to.objects.filter(**self.condition) return _field.rel.to.objects.all() def get_choices(self,_field): return _field.choices
#发送的数据形式： comb_filter = [ FilterOption('gender',is_choice=True), FilterOption('depart',condition={'id__gt':3}), FilterOption('roles',True), ]
如上，通过循环列表，通过实例对象就可以获得封装到类中的所有数据。
8、两个对象相加（__add__)
class Foo(object): def __init__(self,age): self.age = age def __add__(self, other): return self.age + other.age # return Foo(self.age + other.age) obj1 = Foo(19) obj2 = Foo(18) obj3 = obj1 + obj2 print(obj3)
9、类中的方法约束
有这样的情况，我们需要规定多个类中，每一个类中都要一个相同的方法。如何实现这样的约束呢？有两种方式，如下。说明：如下实例要求所有写的类中必须要有send方法，如果没有该方法时，实例化对象调用该方法时会报错。
方式一：抽象类、抽象方法实现
如下实例，我们定义了一个基类BaseMessage，继承抽象类，通过使用@abstractmethod装饰方法send，send方法成为抽象方法，所有继承BaseMessage基类的类中必须要有send方法，否则执行此类时会报错。
from abc import ABCMeta from abc import abstractmethod class BaseMessage(metaclass=ABCMeta): @abstractmethod def send(self,subject,body,to,name): pass ######################################3 class WeChat(BaseMessage): def __init__(self): pass print("xxx") def send(self,subject,body,to,name): print('微信发送成功')
方法二：自定义基类方式实现
如下，自定义基类BaseMessage，在基类中定义一个send方法，方法内抛出没有该方法的异常NotImplementedError。WeChat类继承基类，实例化后调用send方法时，如果此类中没有定义该方法，则会去基类中找。从而会抛出异常。
class BaseMessage(object): def send(self, subject, body, to, name): raise NotImplementedError('未实现send方法') class WeChat(BaseMessage): def __init__(self): pass print("xxx") def send(self,subject,body,to,name): print('微信发送成功')
总结，以上两种方法均在基类中进行特定方法限制，所有继承此基类的类中必须要有此方法。不同的是，方法一中要求所有继承基类的类中必须有抽象方法规定的方法，否则类在实例化的时候就会报错。但是方法二中不同的是，若自定义的类中没有实现send方法时候，在类的实例化过程中不会报错，实例对象可以正常调用类中有的方法和属性，只有实例对象在调用send方法时候会报错。
