类方法和静态方法的不同点,   2、面向对象

黄金时代、面向对象

一,.接口类

生机勃勃、静态方法(staticmethod卡塔 尔(阿拉伯语:قطر‎和类措施(classmethod卡塔尔国

   1、面向进程

  1. 三回九转有两用  

类措施:有个暗中同意参数cls,并且能够直接用类名去调用,能够与类属性人机联作(也正是足以选用类属性卡塔尔国

       a、优点:十分的大的消沉了写程序的复杂度,只需求顺着推行的步骤,堆集代码就可以

  1>:世袭基类的法子,并且做出本身的改造仍旧扩大(代码重用卡塔 尔(英语:State of Qatar)  

静态方法:让类里的诀要直接被类调用,就好像正规调用函数相像

       b、劣点:生龙活虎套流水生产线或然流程正是来消除多个主题材料,代码正是牵一发而地拉那全身

  2>:注明某个子类包容于某基类,定义一个接口类Interface,接口类中定义了一些接口

类措施和静态方法的相似点:都能够一直被类调用,无需实例化

   2、面向对象

      名(正是函数名卡塔 尔(英语:State of Qatar)且从未完毕接口的功能,子类世袭袭口类,并且落成接口中的成效

类方式和静态方法的分化点:

       a、优点:肃清程序的增加性,对某多个目的单独更正,会立刻反应到任何系统中

 

  类方法必需有一个cls参数表示这些类,可以动用类属性

       b、缺点:可控性差,不可能向面向进程的顺序设计流水生产线式的能够很精准的预测难点的拍卖流程与结果,面向对象的主次豆蔻年华旦早先就有对象时期的互相消除难点。

# 一:这样不好,我要统一一下支付的规则.

class QQpay:
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay:
    def pay(self,money):
        print('使用阿里支付%s元' % money)

a = Alipay()
a.pay(100)

b = QQpay()
b.pay(200)


# 二,统一支付的规则 归一化设计,统一 pay接口
class QQpay:
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay:
    def pay(self,money):
        print('使用阿里支付%s元' % money)

def pay(obj,money):        
    obj.pay(money)        #统一调用上面类中pay方法,

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)


# 三,但是,来了一个野生程序员,他不知道你的约定俗成的规则,就会出问题

class QQpay:
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay:
    def pay(self,money):
        print('使用阿里支付%s元' % money)

class Wechatpay:
    def fuqian(self,money):
        print('使用微信支付%s元' % money)

def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)

c = Wechatpay()
c.fuqian(300)


# 四,解决方式
# 定义一个父类,什么都不写,只是要求继承我的所有类有一个pay方法,这样就制定了一个规范,这就叫做接口类,后者抽象类.
class Payment:
    def pay(self):pass

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay(Payment):
    def pay(self,money):
        print('使用阿里支付%s元' % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print('使用微信支付%s元' % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()

pay(a,100)
pay(b,200)

c = Wechatpay()
c.fuqian(300)

#五,他还是不知道看你这些都继承了一个类,所以你要制定一个规范,强制他执行.
# 创建一个规范
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
    @abstractmethod
    def pay(self):pass  # 抽象方法

class Alipay(Payment):
    def pay(self,money):
        print('使用支付宝支付了%s元'%money)

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付了%s元'%money)

class Wechatpay(Payment):
    # def pay(self,money):
    #     print('使用微信支付了%s元'%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 归一化设计:不管是哪一个类的对象,都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的时候才会报错



# 抽象类和接口类做的事情 :建立规范
# 制定一个类的metaclass是ABCMeta,
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范    

  静态方法无需参数

   3、 类:具备相同特征的后生可畏类东西(人、狗、老虎)

  

绑定方法:分为普通方法和类情势

   4、对象/实例:具体的某二个事物(隔壁阿花、楼下旺财卡塔尔

  2. 进行中,世袭的首先种意义意义并不十分的大,以至临时是苛虐对待的。因为它使得子类与基

     普通方法:暗中同意有三个self对象传进来,而且一定要被对象调用-------绑定到指标

   5、实例化:类——>对象的历程

   类出现强耦合。

      类方法:暗中同意有多个cls对象传进来,並且能够被类和对象(不引入卡塔尔调用-----绑定到类

   6、 在python中,用变量表示特征,用函数表示手艺,因此具备同样特征和技巧的风度翩翩类东西正是‘类’,

     1>  世襲的第二种意义极其主要。它又叫“接口世袭”。
      接口世襲实质上是供给“做出二个可观的架空,这几个抽象规定了一个十三分接口,使得外

非绑定方法:静态方法:未有安装暗中认可参数,並且能够被类和目的(不引进卡塔尔调用-----非绑定

   7、对象是则是那生机勃勃类东西中具体的二个

   部调用者无需关怀具体细节,可并列排在一条线的管理完毕了特定接口的具备指标”——那在

图片 1图片 2

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

class 类名:
    类属性 = None
    def __init__(self,对象属性):
        self.对象属性 = 对象属性

    def 方法名(self):
        pass

实例 = 类名(10)
实例.方法名()

   程序设计上,叫做归生龙活虎化。

 1 class Student:
 2     f = open('student', encoding='utf-8')
 3     def __init__(self):
 4         pass
 5     @classmethod #类方法 :有个默认参数cls,并且可以直接使用类名去
 6                  #调用,还可以与类属性交互(也就是可以使用类属性)
 7     def show_student_info_class(cls):
 8         # f = open('student', encoding='utf-8')
 9         for line in cls.f:
10             name,sex = line.strip().split(',')
11             print(name,sex)
12     @staticmethod  #静态方法:可以直接使用类名去调用,就像正常的函数调用一样
13     def show_student_info_static(): #不用传self
14         f = open('student',encoding='utf-8')
15         for line in f:
16             name,sex = line.strip().split(',')
17             print(name,sex)
18 # egon = Student()
19 # egon.show_student_info_static()  #也可以这样调,但是还是推荐用类名去调
20 # egon.show_student_info_class()
21 
22 Student.show_student_info_class()#类名.方法名()
23 print('-------------------')
24 Student.show_student_info_static()#类名.方法名()

    8、类的二种效应:属性援引和实例化

   归生机勃勃化使得高层的表面使用者能够不加区分的拍卖全体接口宽容的指标集结——就好

staticmethod和classmethod

    9、属性引用(类名.属性卡塔尔

   象linux的泛文件概念相仿,全体东西都足以当文件管理,不必关切它是内部存款和储蓄器、磁盘、

一、isinstance 和 issubclass

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

   互连网也许荧屏(当然,对底层设计者,当然也足以分别出“字符设备”和“块设备”,然后

isinstance(obj,cls):检查obj是否cls的目的(传四个参数,多个是指标,七个是类卡塔 尔(英语:State of Qatar)

    10、例化:类名加括号即是实例化,会自动触发__init__函数的周转,能够用它来为各样实例定制本人的表征

   做出针对性的布置:细致到哪些水平,视要求而定卡塔尔国。

issubclass(sub,super):检查sub是或不是super的子类(传四个参数,几个是子类,一个是父类卡塔 尔(英语:State of Qatar)

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

 

 1 class Foo:
 2     pass
 3 class Son(Foo):
 4     pass
 5 s = Son()
 6 print(isinstance(s,Son))  #判断s是不是Son的对象
 7 print(type(s) is Son)
 8 print(isinstance(s,Foo))  #判断s是不是Foo的对象  不精准
 9 print(type(s) is Foo)  #type比较精准
10 
11 print(issubclass(Son,Foo)) #判断Son是不是Foo的子类
12 print(issubclass(Son,object))
13 print(issubclass(Foo,object))
14 print(issubclass(int,object))

    11、

   2> 注意:在python中根本就不曾多个名字为interface的关键字,上边的代码只是看起来像

二、反射

类名
    类名.类属性
   类名.方法名

实例 = 类名(参数,参数)  #实例就是对象

实例
    实例.方法名()
   实例.对象属性

实例增加属性
实例.新的属性名 = 1000
print(实例.新的属性名)

      接口,其实并未起到接口的机能,子类完全能够不用去达成接口 

反射:能够用字符串的艺术去访谈对象的天性,调用对象的不二等秘书诀(然而不能够去拜会方法卡塔 尔(阿拉伯语:قطر‎,python中漫天皆对象,都足以选择反射。

   12、关于self

 

反射有多样艺术:

self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字.

对象/实例只有一种作用:属性引用

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                  #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

dir(类) #返回类中的所有名字列表
isinstance(对象,类) #判断对象是否为类的实例
print(Person.__dict__) # 返回一个字典 key是属性名,value是属性值
print(Person.__module__)  #person类所在的模块
print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名

   3>  接口提取了一堆类一同的函数,能够把接口充任三个函数的成团。 然后让子

hasattr:hasattr(object,name卡塔尔推断多少个对象是不是有name属性也许name方法。有就回到True,未有就回到False

     13、类命名空间与指标、实例的命名空间

    类去得以达成接口中的函数。 这么做的含义在于归意气风发化,什么叫归意气风发化,正是只

getattr:获取对象的习性或然措施,如若存在则打字与印刷出来。hasattr和getattr配套使用

           a、家常便饭二个类就能够创设叁个类的名称空间,用来积存类中定义的拥盛名字,这一个名字改成类的属性

    借使基于同二个接口完结的类,那么全体的这一个类发生的对象在选择时,从用

    要求专心的是,要是回到的是目的的方法,重临出来的是指标的内部存款和储蓄器地址,假若需求周转那么些措施,能够在后边增加意气风发对(卡塔尔

           b、而类有二种个性:静态属性和动态属性

    法上来讲都同样。 归后生可畏化,让使用者没有必要关切对象的类是何许,只必要的知晓

setattr:给指标的属性赋值,若属性不真实,先成立后赋值

  •  静态属性就是一直在类中定义的变量
  • 动态属性正是概念在类中的方法

    那么些指标都富有有个别功用就可以了,那宏大地降落了使用者的运用难度。 比

delattr:删除该对象钦赐的叁天性质

创立三个指标/实例就能成立四个对象/实例的称号空间,存放对象/实例的名字,称为对象/实例的属性

    如:大家定义三个动物接口,接口里定义了有跑、吃、呼吸等接口函数,那样老

图片 3图片 4

形容对象的三结合用法:

    鼠的类去贯彻了该接口,松鼠的类也去实现了该接口,由双方分别发生一头老鼠

 1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 51
 5     def func(self):
 6         print('hello')
 7 egg = Foo()
 8 setattr(egg,'sex','男')
 9 print(egg.sex)
10 # 2.
11 def show_name(self):
12     print(self.name+'sb')
13 setattr(egg,'sh_name',show_name)
14 egg.sh_name(egg)
15 show_name(egg)

重新整合指的是,在一个类中以别的三个类的靶子作为数据属性,称为类的组

    和三头松鼠送到您眼前,即就是您分别不到底哪只是什么鼠你势必驾驭她们都会

setattr

列子:

    跑,都会吃,都能呼吸。 再例如:大家有一个小车接口,里面定义了汽车全体

图片 5图片 6

图片 7图片 8

    的效率,然后由Honda小车的类,奥迪小车的类,大众小车的类,他们都落实了汽

1 delattr(egg,'name')
2 print(egg.name)
from  math  import pi
class Circular:
    def __init__(self,radius):
        self.radius=radius
    def area(self):
        return self.radius **2 * pi
    def perimeter(self):
        return 2 * self.radius * pi
circu=Circular(10)
print(circu.area())
print(circu.perimeter())

    车接口,那样就好办了,我们只要求学会了怎么开小车,那么无论Honda,仍然

delattr

圆的周长与面积

    奥迪,依然公众大家都会开了,开的时候根本没有要求关心笔者开的是哪一类车,操作

1.对象应用反射

     14、面向对象的三大特点

    手法(函数调用卡塔尔国都同大器晚成

图片 9图片 10

           a、继承

 

 1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 51
 5     def func(self):
 6         print('hello')
 7 egg = Foo()
 8 print(hasattr(egg,'name'))  #先判断name在egg里面存在不存在
 9 print(getattr(egg,'name')) #如果为True它才去得到
10 print(hasattr(egg,'func'))
11 print(getattr(egg,'func'))  #得到的是地址
12 # getattr(egg,'func')()  #在这里加括号才能得到,因为func是方法
13 if hasattr(egg,'func'):
14     getattr(egg,'func')()
15 else:
16     print('没找到')
class Animal:      #父类  基类  超类
    def __init__(self,name,life_value,aggr):
        self.name = name
        self.life_value = life_value
        self.aggr = aggr


class Person(Animal):  #子类  派生类
    pass

class Dog(Animal): #子类  派生类
    pass

egg = Person('egon',1000,50)
print(egg.name)
print(egg.aggr

二,  抽象类

对象应用反射

       

  1. 怎么着是抽象类

2.类应用反射

python2
class Dad:  #经典类
class Dag(object)  #新式类

python3
class Dad  ==  class Dag(object) #新式类

*     * 与java同样,python也可能有抽象类的概念可是相似必要正视模块完毕,抽象类是四个特种

图片 11图片 12

              1、世袭的语法

   的类,它的十分之处在于只好被接二连三,不可能被实例化

 1 class Foo:
 2     f = 123
 3     @classmethod
 4     def class_method_dome(cls):
 5         print('class_method_dome')
 6 
 7     @staticmethod
 8     def static_method_dome():
 9         print('static_method_dome')
10 print(hasattr(Foo,'class_method_dome'))
11 method = getattr(Foo,'class_method_dome')
12 method()
13 print('------------')
14 print(hasattr(Foo,'static_method_dome'))
15 method1 = getattr(Foo,'static_method_dome')
16 method1()
 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

继承、抽象、派生
继承 是从大范围到小范围
抽象 小范围到大范围
派生 就是在父类的基础上又产生子类——派生类
        父类里没有的 但子类有的 ——派生方法
        派生属性
方法的重写
    父类里有的方法,在子类里重新实现

 

 

类使用反射

              2、世襲的两种用途:                

  2. 为啥要有抽象类

3.模块应用反射

                  b:世襲基类的艺术,而且做出本身的改造恐怕增加(代码重用卡塔尔国***  ***

   如果说类是从一堆对象中收取相通的剧情而来的,那么抽象类是从一堆中抽出相通

 模块的接收又分为导入别的模块反射和在本模块中反射

                  a:注明有个别子类宽容于某基类,定义三个接口类Interface,接口类中定义

   的内容而来的,内容包蕴数据属性和函数属性。

图片 13图片 14

                         ** 了豆蔻梢头部分接口名(就是函数名卡塔 尔(阿拉伯语:قطر‎且未有完结接口的效率,子类继承袭口类,何况实现接口中的效用**

    比如大家有天宝蕉的类,有苹果的类,有光桃的类,从那几个类抽出雷同的内容正是鲜果那

1 # 1.导入其他模块引用
2 import mymodule
3 print(hasattr(mymodule,'test'))
4 getattr(mymodule,'test')()
5 
6 # # 这里的getattr(mymodule,'test')()这一句相当于
7 # p = getattr(mymodule,'test')
8 # p()

           b、封装

   个抽象的类,你吃水果时,要么是吃贰个切实的金蕉,要么是吃一个切实的黄肉桃,你恒久

导入别的模块反射

                  1、优点:

   不能够吃到一个名为水果的事物。

图片 15图片 16

                              a、将转移隔绝

      从设计角度去看,若是类是从现实对象抽象而来的,那么抽象类正是依靠类大而无当而来的。

1 # 2.在本模块中应用反射
2 def demo1():
3     print('wwww')
4 import sys
5 # print(sys.modules)
6 module_obj = sys.modules[__name__]  #相当于'__main__'
7 print(module_obj)
8 print(hasattr(module_obj,'demo1'))
9 getattr(module_obj,'demo1')()

                              b、封装使用

    从落实角度来看,抽象类与普通类的差异之处在于:抽象类中有抽象方法,该类不能够被

在本模块中运用反射

                              c、进步复用性

   实例化,只可以被接续,且子类必需达成抽象方法。那或多或少与接口有一些形似,但实际上是不

图片 17图片 18

                              d、进步安全性

   同的.

 1 # 举例
 2 def 注册():
 3     print('regiester')
 4 def 登录():
 5     print('login')
 6 def 购物():
 7     pass
 8 print('注册,登录,购物')
 9 ret = input('请输入你要做的操作:')
10 import sys
11 my_module = sys.modules[__name__]  #利用sys模块导入一个自己的模块
12 if hasattr(my_module,ret):
13     getattr(my_module,ret)()

                  2、封装原则:

 

导入自个儿的模块的一个差不离小例子

                              a、将无需对外提供的内容都掩藏起来

 

三、内置方法

                              b、把品质都走避起来提供公共艺术对其访谈

  2. 抽象类与接口类

1.__str__和__repr__

                  3、私有变量和私家方法

   抽象类的真面目依然类,指的是黄金时代组类的形似性,包罗数据属性(如all_type卡塔尔国和函数属

变动指标的字符串展现

                              a、在python中用双写道的开始的的办法降属性隐蔽起来(设置个人的卡塔 尔(阿拉伯语:قطر‎

   性(如read、write卡塔尔国,而接口只重申函数属性的相像性

图片 19图片 20

property属性

   抽象类是一个在于类和接口直接的贰个概念,同期具备类和接口的局地本性,能够

 1 class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4     def __repr__(self):
 5         return 'obj in str'  #这里只能是return
 6     # def __str__(self):
 7     #     return '%s obj in str'%self.name
 8 f = Foo('egon')
 9 print(f)  #优先执行__str__里面的内容
10 # 那么你是不是据地__repr__没用呢?
11 # print('%s'%f)  #执行的是__str__里面的返回值
12 # print('%r'%f)  #执行的是__repr__里面的返回值
13 print('==============')
14 print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
15 print(repr(f))
16 #1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
17 # 2.当__str__没有被实现的时候,就会调用__repr__方法
18 # 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
19 # 4.不管是在字符串格式化的时候还是在打印对象的时候,
20 # __repr__方法都可以作为__str__方法的替补,但反之则不行
21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__

property是大器晚成种特有的质量,访谈它时会实践黄金时代段功效(函数卡塔尔国然后重返值

   用来贯彻归风姿浪漫化设计 

__str__和__repr__

  

   

 2.__del__

           c、多态:”多态指的是风姿洒脱类东西有八种模样(举例:老师.下课铃响了(卡塔尔,学子.下课铃响了(),老师实施的是下班操作,学生实践的是放学操作,固然双方信息一点差距也未有于,可是举办的意义差别卡塔尔国

  3. 在python中,并从未接口类这种事物,即便不通过特地的模块定义接口,大家也应有有

析构方法,当对象在内部存款和储蓄器中被假释时,自动触发执行。

                   多态指的是:风华正茂类东西有三种场馆

   一些着力的概念。

注:此办法经常不要定义,因为Python是一门高等语言,程序猿在采纳时不须要关切内部存款和储蓄器的分红和假释,因为此职业都以交给Python解释器来推行,所以,析构函数的调用是由解释器在张开垃圾回笼时自动触发实施的。

python自带多态:

  多态:同一类事物的多种状态

  python里处处都是多态,只是我们一般发现不了

  操作的时候不需要关心这个对象的数据类型,你只要用就行了

 

1 class Foo:
2     def __del__(self):
3         print('执行我啦')
4 
5 f= Foo()
6 print(123)
7 print(123)
8 print(123)
9 print(123)

 

  4. 多再三再四难点

3.item系列

    15、反射     

    在继续抽象类的进程中,我们应当尽量制止多接二连三;
    而在那起彼伏接口的时候,大家反而激励你来多再三再四接口

分别有__getitem__      ,__setitem__    ,__delitem__

        1、 反射:能够用字符串的秘技去拜会对象的性质,调用对象的章程(不过不可能去访谈方法卡塔尔,python中全体皆对象,都足以应用反射。

 
  
  5. 接口隔离原则:
  使用多个专门的接口,而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

图片 21图片 22

        2、反射有三种方法:

 

 1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 73
 5         self.l=[1,2,3]
 6     def __getitem__(self, item):  #得到
 7         # return  self.l[item]
 8         # return self.__dict__[item]
 9         # print(Foo.__dict__)
10         return 123
11     def __setitem__(self, key, value):  #修改
12         print(key,value)
13         self.__dict__[key] = value
14     def __delitem__(self, key):  #删除
15         del self.__dict__[key]
16 f = Foo()
17 print(f['qqq'])  #不管里面放的啥值,它都会得到返回值的内容,调用的是__getitem__方法
18 f['name']='alex' #修改egon的值为alex,调用 __setitem__方法
19 # del f['name'] #删除name,就会报错了,说明在调用__delitem__方法调用成功了,就已经删了,就会报错了
20 print(f.name) 
21 f1 = Foo()
22 print(f == f1)
23 # print(f.name)
24 # print(f[0])  #一开始不能这样取值,但是提供了一个__getitem__方法,这样就可以用了
25 # print(f[1])
26 # print(f[2])

               hasattr:hasattr(object,name卡塔 尔(英语:State of Qatar)判定三个对象是或不是有name属性也许name方法。有就重临True,未有就回来False

  6. 方法的达成

多少个点子的行使

              getattr:获取对象的品质也许措施,即便存在则打字与印刷出来。hasattr和getattr配套使用

   在抽象类中,我们能够对风流浪漫部分华而不实方法做出底子完结;
   而在接口类中,任何措施都只是生龙活虎种规范,具体的职能需求子类完毕

4.__new__(创建)

                 供给注意的是,倘若回到的是指标的措施,重返出来的是目的的内存地址,要是需求周转那几个点子,能够在前面加多生机勃勃对(卡塔尔国

 

图片 23图片 24

               setattr:给指标的性质赋值,若属性官样文章,先成立后赋值

三, 多态

 1 # 4.__new__方法
 2 # 单例模式:是一种设计模式
 3 class Singleton:
 4     def __new__(cls, *args, **kw):
 5         if not hasattr(cls, '_instance'):
 6             orig = super(Singleton, cls)
 7             cls._instance = orig.__new__(cls, *args, **kw)
 8         return cls._instance
 9 
10 one = Singleton()
11 two = Singleton()
12 print(one,two)   #他们两个的地址一样
13 
14 one.name = 'alex'
15 print(two.name) 

               delattr:删除该指标钦赐的壹天性质

 

单例格局

          a、内置方法:isinstance和issubclass

  1. Pyhon不支持Java和C#那黄金时代类强类型语言中多态的写法,不过原生多态,其Python崇尚

图片 25图片 26

               isinstance(obj,cls)检查是或不是obj是还是不是是类 cls 的对象

   “红鸭类型”

 1 # class A:
 2 #     def __init__(self):  #有一个方法在帮你创造self
 3 #         print('in init function')
 4 #         self.x = 1
 5 #
 6 #     def __new__(cls, *args, **kwargs):
 7 #         print('in new function')
 8 #         return object.__new__(A, *args, **kwargs)
 9 # a = A()
10 # b = A()
11 # c = A()
12 # d = A()
13 # print(a,b,c,d)
class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))
class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'


# 由于在Java或C#中定义函数参数时,必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类
# 而实际传入的参数是:S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj,执行 S1 的show方法,结果:S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj,执行 Ss 的show方法,结果:S2.show

Python伪代码实现Java或C#的多态

Python伪代码实现java C#多态

#鸭子类型

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj) 

#都有同样的方法,使用上类似,具有统一化设计思想,就叫鸭子类型

__new__

        b、内置方法:issubclass(sub, super)检查sub类是还是不是是 super 类的派生类 

 

5.__call__

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

 

指标后边加括号,触发施行

 

四, 封装

注:结构方法的施行是由创制对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的实践是由对象后加括号触发的,即:对象() 也许 类()()

       c、python面向对象中的反射:通过字符串的花样操作对象相关的性格,python中任何事物都以指标(都能够用反射卡塔尔

 

图片 27图片 28

检查是否含有某属性---hasattr 返回布尔值
获取属性---getattr   没有就会报错
设置属性---setattr
删除属性---delattr

 

1 class Foo:
2     def __call__(self, *args, **kwargs):
3         print(123)
4 # f = Foo()
5 # f() #如果不写上面的__call__方法,就不会调用。如果加上,就正确了
6 Foo()() #也可以这样表示

       d、内置方法:__del__

  1. 打包,看名就会知道意思正是将内容封装到某些地方,今后再去调用被封装在某处的原委。

__call__

析构方法,当对象在内部存款和储蓄器中被放出时,自动触发实践。

   所以,在运用面向对象的封装个性时,供给:

6.__len__

注:此办法日常不要定义,因为Python是一门高档语言,技术员在利用时不需求关切内部存款和储蓄器的分配和释放,因为此干活都以交给Python解释器来执行,所以,析构函数的调用是由解释器在开展垃圾回笼时自动触发实践的。

    •  将内容封装到某处
    •  从某处调用被装进的内容

图片 29__len__

class Foo:
    def __del__(self):
        print('fgs')
f=Foo()
print(123)
print(123)
del f
print(123)
print(123)
print(123)

  

7.__hash__

 

  2. 将内容封装到某处

图片 30图片 31

     e、内置方法:item系列

图片 32

1 class Foo:
2     def __hash__(self):
3         print('aaaaaaaaaa')
4         return hash(self.name)
5         # print('aaas')
6 f = Foo()
7 f.name = 'egon'
8 print(hash(f))  #hash方法是可以重写的

__getitem____setitem____delitem__

    __new__

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

     f、__str__和__repr__改革目的的字符串展现

图片 33图片 34

class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4     def __repr__(self):
 5         return 'obj in str'  #这里只能是return
 6     # def __str__(self):
 7     #     return '%s obj in str'%self.name
 8 f = Foo('egon')
 9 print(f)  #优先执行__str__里面的内容
10 # 那么你是不是据地__repr__没用呢?
11 # print('%s'%f)  #执行的是__str__里面的返回值
12 # print('%r'%f)  #执行的是__repr__里面的返回值
13 print('==============')
14 print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
15 print(repr(f))
16 #1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
17 # 2.当__str__没有被实现的时候,就会调用__repr__方法
18 # 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
19 # 4.不管是在字符串格式化的时候还是在打印对象的时候,
20 # __repr__方法都可以作为__str__方法的替补,但反之则不行
21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__

__str__,__repr__

    15、内置方法

           a、静态方法和类措施

               1、类措施:有个暗许参数cls,並且能够一向用类名去调用,能够与类属性人机联作(相当于能够运用类属性卡塔 尔(阿拉伯语:قطر‎

               2、静态方法:让类里的点子间接被类调用,犹如正规调用函数同样

           b、类措施和静态方法的相近点:都得以一贯被类调用,不须求实例化

           c、类措施和静态方法的不一样点:

          类方法必得有三个cls参数表示这一个类,能够运用类属性

           静态方法无需参数

           d、绑定方法:分为普通方法和类措施

     普通方法:暗中同意有多少个self对象传进来,並且只好被对象调用-------绑定到对象

     类方法:私下认可有一个cls对象传进来,何况能够被类和目的(不引入卡塔 尔(英语:State of Qatar)调用-----绑定到类

            e、非绑定方法:静态方法:未有设置暗中同意参数,並且能够被类和对象(不推荐卡塔尔国调用-----非绑定

    16、接口类与抽象类

             a、 接口类:(在抽象类的根基上卡塔尔国

         在python中,私下认可是未曾接口类的           

                    接口类不可能被实例化(假如实例化会报错卡塔 尔(阿拉伯语:قطر‎

          接口类中的方法不可能被达成

接口也就是做约束,让下面的类的方法都按照接口类中给出的方法去定义。如果接口类里面有的方法类里面没有,那么那个类就不能被实例化。(字面理解)

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

           b、抽象类

在python中,默认是有的

    父类的方法,子类必须实现

    抽象类(父类)的方法可以被实现

抽象类和接口类的区别:接口类不能实现方法,抽象类可以实现方法里面的内容

抽象类和接口类的相同点:都是用来做约束的,都不能被实例化

抽象类和接口类的使用:

  当几个子类的父类有相同的功能需要被实现的时候就用抽象类

  当几个子类有相同的功能,但是实现各不相同的时候就用接口类

 

 

__hash__

   self 是三个样式参数,当实行 obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj1

8.__eq__

                                   当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2

图片 35图片 36

 

1 class A:
2     def __eq__(self, other):
3         return True
4 a = A()
5 b = A()
6 print(a==b) #不加方法的时候返回的是False,加了个__eq__方法就返回了个True
7 # '=='内部就调用了__eq__方法
8 print(a is b)

  所以,内容实在被包裹到了对象 obj1 和 obj2 中,种种对象中都有 name 和 age 属性,

__eq__

  在内部存款和储蓄器里好像于下图来保存。

 生机勃勃道面课题

 

图片 37面试题

本文由必威发布于必威-编程,转载请注明出处:类方法和静态方法的不同点,   2、面向对象

相关阅读