威尼斯人线上娱乐

零基础分分钟通晓python面向对象那些事您也行,面向对象进阶

28 3月 , 2019  

壹 、面向对象

Python之面向对象计算,python面向对象

壹 、面向对象

   一 、面向进度

     
 a、优点:不小的暴跌了写程序的复杂度,只要求顺着执行的步子,堆叠代码即可

     
 b、缺点:一套流水生产线恐怕流程就是来化解3个题材,代码正是牵一发而郑州全身

   ② 、面向对象

     
 a、优点:化解程序的扩张性,对某三个对象单独修改,会立刻反应到全方位体系中

     
 b、缺点:可控性差,无法向面向进度的次第设计流水生产线式的能够很精准的前瞻难题的拍卖流程与结果,面向对象的程序一旦初叶就有指标之间的并行解决难题。

   3、 类:具有同等特征的一类东西(人、狗、老虎)

   肆 、对象/实例:具体的某三个事物(隔壁阿花、楼下旺财)

   五 、实例化:类——>对象的经过

   6、在python中,用变量表示特征,用函数表示技术,由此具有同等特征和技艺的一类东西便是‘类’,

   ⑦ 、对象是则是这一类东西中实际的三个

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

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

    def 方法名(self):
        pass

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

    八 、类的三种效应:属性引用和实例化

    九 、属性引用(类名.属性)

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


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

   
⑩ 、例化:类名加括号就是实例化,会活动触发__init__函数的运作,能够用它来为各类实例定制本人的性状

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)  #引用人的走路方法,注意,这里不是在调用

    11、

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

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

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

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

   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__)) #字符串数据类型的类名

     1③ 、类命名空间与对象、实例的命名空间

         
 a、常见八个类就会成立一个类的称号空间,用来储存类中定义的具著名字,这么些名字改成类的性格

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

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

创立几个对象/实例就会成立贰个目的/实例的称谓空间,存放对象/实例的名字,称为对象/实例的本性

长相对象的结缘用法:

重组指的是,在3个类中以其它2个类的目的作为数据属性,称为类的组

列子:

威尼斯人线上娱乐 1

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

圆的周长与面积

     1④ 、面向对象的三大特征

           a、继承

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

零基础分分钟通晓python面向对象那些事您也行,面向对象进阶。       

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

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

              ① 、继承的语法

 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

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

 

              二 、继承的二种用途:                

                 
b:继承基类的艺术,并且做出自个儿的改变可能扩大(代码重用)***
  ***

                 
a:注脚某些子类包容于某基类,定义二个接口类Interface,接口类中定义

                       
 **
 了有些接口名(正是函数名)且没有达成接口的效果,子类继承接口类,并且实现接口中的作用**

           b、封装

                  1、优点:

                              a、将转移隔绝

                              b、封装使用

                              c、进步复用性

                              d、升高安全性

                  ② 、封装原则:

                              a、将不要求对外提供的始末都躲藏起来

                              b、把质量都躲藏起来提供公共艺术对其访问

                  叁 、私有变量和私家方法

                             
a、在python中用双涂鸦的启幕的的法门降属性隐藏起来(设置个人的)

property属性

property是一种独特的习性,访问它时会执行一段功能(函数)然后重返值

  

         
 c、多态:”多态指的是一类东西有各类形状(比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生举行的是放学操作,即使两者音讯没有差距于,不过执行的作用差异)

                   多态指的是:一类东西有种种景观

python自带多态:

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

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

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

 

    15、反射     

        一 、反射:能够用字符串的章程去做客对象的习性,调用对象的措施(不过不可能去访问方法),python中一切皆对象,都能够利用反射。

        ② 、反射有各个办法:

             
 hasattr:hasattr(object,name)判断多个指标是还是不是有name属性可能name方法。有就回去True,没有就回去False

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

                
供给注意的是,借使回到的是指标的章程,再次回到出来的是指标的内部存款和储蓄器地址,假设须求周转那一个艺术,可以在前面添加一对()

               setattr:给指标的质量赋值,若属性不存在,先创造后赋值

               delattr:删除该指标钦定的1性情质

          a、内置方法:isinstance和issubclass

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

class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))

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

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

 

     
 c、python面向对象中的反射:通过字符串的花样操作对象相关的属性,python中漫天事物都以指标(都得以用反射)

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

       d、内置方法:__del__

析构方法,当对象在内存中被假释时,自动触发执行。

注:此措施一般不要定义,因为Python是一门高级语言,程序员在采纳时无需关心内部存款和储蓄器的分红和自由,因为此工作都以付出Python解释器来施行,所以,析构函数的调用是由解释器在拓展垃圾回收时自动触发执行的。

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

 

     e、内置方法:item系列

威尼斯人线上娱乐 2

一,.接口类

   一 、面向进程

__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__转移目的的字符串显示

威尼斯人线上娱乐 3

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__

    1五 、内置方法

           a、静态方法和类措施

             
 ① 、类方式:有个默许参数cls,并且能够直接用类名去调用,能够与类属性交互(也正是足以应用类属性)

             
 贰 、静态方法:让类里的主意直接被类调用,就像是平常调用函数一样

           b、类措施和静态方法的相同点:都能够一向被类调用,不要求实例化

           c、类格局和静态方法的差别点:

          类方法必须有3个cls参数表示这一个类,能够采纳类属性

           静态方法不须要参数

           d、绑定方法:分为一般方法和类格局

     普通方法:暗中认可有多个self对象传进来,并且只可以被对象调用——-绑定到对象

     类方法:暗中认可有一个cls对象传进来,并且能够被类和指标(不推荐)调用—–绑定到类

           
e、非绑定方法:静态方法:没有安装私下认可参数,并且可以被类和目的(不引进)调用—–非绑定

    1⑥ 、接口类与抽象类

             a、 接口类:(在抽象类的底子上)

         在python中,暗许是从未接口类的           

                    接口类无法被实例化(如果实例化会报错)

          接口类中的方法无法被达成

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

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

           b、抽象类

在python中,默认是有的

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

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

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

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

抽象类和接口类的使用:

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

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

 

一 、面向对象
① 、面向过程a、优点:非常的大的减退了写程序的复杂度,只须求顺着执行的手续,堆叠代…

壹 、面向对象

  1. 无冕有二种用途  

     
 a、优点:非常的大的降低了写程序的复杂度,只需求顺着执行的步调,堆叠代码即可

壹 、面向进度

  1>:继承基类的法子,并且做出本身的改变或许扩大(代码重用)  

     
 b、缺点:一套流水生产线可能流程就是来化解2个难题,代码就是牵一发而香岛全身

a、优点:非常大的降低了写程序的复杂度,只需求顺着执行的手续,堆叠代码即可

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

   贰 、面向对象

b、缺点:一套流水生产线可能流程就是来消除2个题材,代码正是牵一发而西安全身

     
名(便是函数名)且并未达成接口的职能,子类继承接口类,并且完毕接口中的功效

     
 a、优点:消除程序的扩充性,对某一个目的单独修改,会应声反应到总体种类中

二 、面向对象

 

     
 b、缺点:可控性差,不能够向面向进程的主次设计流水生产线式的能够很精准的预测问题的处理流程与结果,面向对象的程序一旦起先就有指标时期的交互消除难题。

a、优点:消除程序的扩充性,对某二个对象单独修改,会应声反应到一切种类中

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

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,
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范    

   ③ 、 类:具有相同特征的一类东西(人、狗、老虎)

b、缺点:可控性差,不可能向面向进程的顺序设计流水生产线式的能够很精准的测度难点的拍卖流程与结果,面向对象的先后一旦初叶就有目的之间的相互化解难题。

  

   肆 、对象/实例:具体的某八个事物(隔壁阿花、楼下旺财)

叁 、 类:具有同等特征的一类东西(人、狗、老虎)

  2.
实行中,继承的首先种意义意义并不非常的大,甚至不时是有毒的。因为它使得子类与基

   伍 、实例化:类——>对象的长河

④ 、对象/实例:具体的某1个东西(隔壁阿花、楼下旺财)

   类出现强耦合。

   陆 、在python中,用变量表示特征,用函数表示技术,由此具有同样特征和技术的一类东西便是‘类’,

五 、实例化:类——>对象的长河

     1>  继承的第两种意义非凡重要。它又叫“接口继承”。
    
 接口继承实质上是讲求“做出二个美艳的悬空,这一个抽象规定了贰个11分接口,使得外

   ⑦ 、对象是则是这一类东西中切实的二个

6、在python中,用变量表示特征,用函数表示技术,由此具有同样特征和技术的一类东西正是‘类’,

   部调用者无需关心具体细节,可并排的处理达成了一定接口的装有目的”——这在

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

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

    def 方法名(self):
        pass

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

七 、对象是则是这一类东西中切实的1个

   程序设计上,叫做归一化。

    八 、类的二种意义:属性引用和实例化

class Person: #概念3个生人

   归一化使得高层的表面使用者能够不加区分的拍卖全数接口包容的指标集合——就好

    九 、属性引用(类名.属性)

role = ‘person’ #人的角色属性都以人

   象linux的泛文件概念一样,全数东西都能够当文件处理,不必关注它是内部存款和储蓄器、磁盘、

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


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

def walk(self): #人都得以走路,也正是有1个行进方法,也叫动态属性

   互连网只怕显示屏(当然,对底层设计者,当然也能够区分出“字符设备”和“块设备”,然后

   
十 、例化:类名加括号正是实例化,会活动触发__init__函数的运营,能够用它来为种种实例定制自身的特点

print(“person is walking…”)

   做出针对性的设计:细致到怎么样水平,视必要而定)。

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)  #引用人的走路方法,注意,这里不是在调用

class 类名:

 

    11、

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

   2>
注意:在python中平昔就没有二个誉为interface的主要字,上边包车型客车代码只是看起来像

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

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

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

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

self.对象属性 = 对象属性 def 方法名(self): pass实例 = 类名(10)

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

   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__)) #字符串数据类型的类名

威尼斯人线上娱乐 4

   3>
 接口提取了一群类一起的函数,能够把接口当做2个函数的集纳。
然后让子

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

⑧ 、类的二种功效:属性引用和实例化

    类去达成接口中的函数。
这么做的意义在于归一化,什么叫归一化,便是只

         
 a、常见贰个类就会创设二个类的名称空间,用来储存类中定义的具备名字,这几个名字改成类的性质

九 、属性引用(类名.属性)

    就算按照同1个接口完成的类,那么富有的那个类发生的靶子在选择时,从用

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

class Person: #概念三个生人

    法上来说都同一。
归一化,让使用者无需关心对象的类是怎么,只须求的理解

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

role = ‘person’ #人的角色属性都是人

    那一个指标都兼备有些作用就能够了,那庞大地降落了使用者的运用难度。

制造三个指标/实例就会创立1个目的/实例的名称空间,存放对象/实例的名字,称为对象/实例的习性

def walk(self): #人都得以走路,也正是有1个行进方法

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

形容对象的构成用法:

print(“person is walking…”)print(Person.role)
#翻看人的role属性print(Person.walk)
#引用人的走动方法,注意,那里不是在调用。作者推荐二个学Python的求学裙【五八八,零九零,九四二】,无论你是大腕照旧小白,是想转行依然想入行都能够来打听一起前进一起学习!裙内有众多干货和技能分享

    鼠的类去实现了该接口,松鼠的类也去贯彻了该接口,由两岸分别发出2头老鼠

结缘指的是,在3个类中以别的二个类的指标作为数据属性,称为类的组

⑩ 、例化:类名加括号就是实例化,会活动触发__init__函数的运作,能够用它来为各类实例定制自身的性状

    和二只松鼠送到你眼前,即正是您分别不到底哪只是如何鼠你势必知道他们都会

列子:

class Person: #概念1个人类

    跑,都会吃,都能呼吸。
再譬如:我们有三个小车接口,里面定义了小车具备

威尼斯人线上娱乐 5威尼斯人线上娱乐 6

role = ‘person’ #人的剧中人物属性都以人

    的效益,然后由Honda汽车的类,Audi小车的类,Subaru小车的类,他们都落到实处了汽

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

def __init__(self,name):

    车接口,那样就好办了,大家只须求学会了怎么开小车,那么不论Honda,依然

圆的周长与面积

self.name = name # 每多个剧中人物都有谈得来的外号;

    奥迪(奥迪),依然公众大家都会开了,开的时候根本无需关切作者开的是哪一种车,操作

     1四 、面向对象的三大特色

def walk(self): #人都得以走路,也正是有二个行进方法

    手法(函数调用)都同一

           a、继承

print(“person is walking…”)print(Person.role)
#翻开人的role属性print(Person.walk)
#引用人的行动方法,注意,那里不是在调用

 

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

11、

二,  抽象类

       

类名

  1. 哪些是抽象类

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

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

类名.类属性

*     *
与java一样,python也有抽象类的定义然而同样必要借助模块实现,抽象类是多个非凡

              壹 、继承的语法

类名.方法名

   的类,它的与众不相同之处在于只可以被延续,不可能被实例化

 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

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

 

实例 = 类名(参数,参数) #实例正是指标实例

 

              ② 、继承的二种用途:                

实例.方法名()

  2. 为什么要有抽象类

                 
b:继承基类的章程,并且做出本人的改变可能扩大(代码重用)***
  ***

实例.对象属性

   如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同

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

实例增添属性

威尼斯人线上娱乐,   的剧情而来的,内容囊括数据属性和函数属性。

                       
 **
 了一部分接口名(就是函数名)且并未实现接口的功用,子类继承接口类,并且达成接口中的功效**

实例.新的属性名 = 一千print(实例.新的属性名)

   
比如我们有香蕉的类,有苹果的类,有桃子的类,从那几个类抽取相同的内容正是水果那

           b、封装

12、关于self

   个抽象的类,你吃水果时,要么是吃二个有血有肉的香蕉,要么是吃2个切实可行的桃子,你永远

                  1、优点:

self:在实例化时自动将对象/实例本人传给__init__的第二个参数,你也足以给她起分其余名字.

   不也许吃到二个名为水果的事物。

                              a、将转移隔离

目的/实例唯有一种功用:属性引用

     
从规划角度去看,假若类是从现实对象抽象而来的,那么抽象类正是遵照类华而不实而来的。

                              b、封装使用

class 类名: def __init__(self,参数1,参数2):

   
从贯彻角度来看,抽象类与普通类的不相同之处在于:抽象类中有抽象方法,该类不可能被

                              c、提升复用性

self.对象的性质1 = 参数1

   实例化,只可以被三番陆遍,且子类必须贯彻抽象方法。那或多或少与接口有点类似,但骨子里是不

                              d、进步安全性

self.对象的习性2 = 参数2 def 方法名(self):pass

   同的.

                  贰 、封装原则:

def 方法名2(self):pass对象名 = 类名(1,2)
#目的就是实例,代表2个实际的事物

 

                              a、将不需求对外提供的情节都掩藏起来

#类名() : 类名+括号就是实例化七个类,相当于调用了__init__方法

 

                              b、把质量都隐藏起来提供公共措施对其访问

#括号里传参数,参数不供给传self,别的与init中的形参一一对应

  2. 抽象类与接口类

                  三 、私有变量和个体方法

#结果回到三个指标目的名.对象的性质1 #翻看对象的属性,直接用
对象名.属性名 即可对象名.方法名() #调用类中的方法,直接用
对象名.方法名() 即可

   抽象类的真相还是类,指的是一组类的相似性,包含数据属性(如all_type)和函数属

                             
a、在python中用双涂鸦的发端的的艺术降属性隐藏起来(设置个人的)

威尼斯人线上娱乐 7

   性(如read、write),而接口只强调函数属性的相似性

property属性

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

   抽象类是3个在于类和接口直接的多少个概念,同时具备类和接口的部分个性,能够

property是一种独特的本性,访问它时会执行一段效能(函数)然后再次回到值

1三 、类命名空间与目的、实例的命名空间

   用来落到实处归一化设计 

  

a、常见1个类就会成立二个类的称号空间,用来储存类中定义的装盛名字,那几个名字改成类的质量

   

         
 c、多态:”多态指的是一类东西有三种造型(比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生实施的是放学操作,即使两者音信一点差异也没有于,然而实施的效劳差异)

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

  3.
在python中,并不曾接口类那种事物,即使不经过专门的模块定义接口,大家也理应有

                   多态指的是:一类东西有四种状态

静态属性便是直接在类中定义的变量

   一些为主的概念。

python自带多态:

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

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

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

动态属性正是概念在类中的方法

 

 

开创八个对象/实例就会创制多个指标/实例的称号空间,存放对象/实例的名字,称为对象/实例的性质

  4. 多再而三问题

    15、反射     

面容对象的结缘用法:

    在此起彼伏抽象类的历程中,大家相应尽量幸免多接二连三;
    而在一连接口的时候,大家反而鼓励你来多两次三番接口

        壹 、反射:能够用字符串的格局去访问对象的性情,调用对象的方法(可是不可能去拜访方法),python中漫天皆对象,都能够动用反射。

重组指的是,在三个类中以其它八个类的靶子作为数据属性,称为类的组

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

        二 、反射有八种格局:

列子:

 

             
 hasattr:hasattr(object,name)判断1个指标是还是不是有name属性或许name方法。有就赶回True,没有就赶回False

圆的周长与面积

  6. 方法的兑现

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

1四 、面向对象的三大特点

   在抽象类中,我们能够对有的架空方法做出基础达成;
   而在接口类中,任何方式都只是一种标准,具体的作用供给子类完结

                
供给专注的是,借使回到的是指标的章程,重回出来的是目的的内部存款和储蓄器地址,假如急需周转那几个措施,能够在背后添加一对()

a、继承

 

               setattr:给目的的属性赋值,若属性不存在,先成立后赋值

class Animal: #父类 基类 超类

三, 多态

               delattr:删除该指标钦点的一个属性

def __init__(self,name,life_value,aggr):

 

          a、内置方法:isinstance和issubclass

self.name = name

  1.
Pyhon不支持Java和C#这一类强类型语言中多态的写法,然而原生多态,其Python崇尚

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

self.life_value = life_value

   “鸭子类型”

class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))

self.aggr = aggrclass Person(Animal): #子类 派生类

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) 

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

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

passclass Dog(Animal): #子类 派生类

 

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

passegg = Person(‘egon’,1000,50)print(egg.name)print(egg.aggr

 

 

python2class Dad: #经典类class Dag(object) #新式类python3class Dad ==
class Dag(object) #新式类

四, 封装

     
 c、python面向对象中的反射:通过字符串的样式操作对象相关的习性,python中一切事物都是目的(都足以用反射)

① 、继承的语法

 

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

class 类名(父类名): 想在子类中贯彻调用父类的方法 在类内
——super(子类名,self).方法名() 在类外面 ——super(子类名,对象名).方法名()
倘诺不内定继承的父类,暗中认可继承object 子类能够动用父类的全体属性和措施
假若子类有谈得来的法门就实施本人的的 固然是子类没有的章程就进行父类的
假设子类父类都不曾那个法子就报错

 

       d、内置方法:__del__

继承、抽象、派生

  1.
包裹,顾名思义就是将内容封装到某些位置,现在再去调用被封装在某处的始末。

析构方法,当目的在内部存款和储蓄器中被放飞时,自动触发执行。

继续 是从大范围到小范围

   所以,在利用面向对象的封装天性时,须要:

注:此情势一般不要定义,因为Python是一门高级语言,程序员在使用时无需关怀内部存款和储蓄器的分配和假释,因为此工作都是付诸Python解释器来执行,所以,析构函数的调用是由解释器在展开垃圾回收时自动触发执行的。

抽象 小范围到大范围

    •  将内容封装到某处
    •  从某处调用被包裹的剧情
class Foo:
    def __del__(self):
        print('fgs')
f=Foo()
print(123)
print(123)
del f
print(123)
print(123)
print(123)

派生 正是在父类的底子上又生出子类——派生类

  

 

父类里没有的 但子类有的 ——派生方法

  2. 将内容封装到某处

     e、内置方法:item系列

派生属性

威尼斯人线上娱乐 8

__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__更改目的的字符串突显

威尼斯人线上娱乐 9威尼斯人线上娱乐 10

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__

    1伍 、内置方法

           a、静态方法和类方式

             
 一 、类措施:有个私下认可参数cls,并且能够平昔用类名去调用,能够与类属性交互(也正是可以利用类属性)

             
 贰 、静态方法:让类里的办法直接被类调用,仿佛正规调用函数一样

           b、类格局和静态方法的相同点:都足以从来被类调用,不供给实例化

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

          类方法必须有四个cls参数表示这几个类,能够采纳类属性

           静态方法不须求参数

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

     普通方法:暗中认可有3个self对象传进来,并且不得不被对象调用——-绑定到目的

     类方法:暗中同意有二个cls对象传进来,并且能够被类和对象(不推荐)调用—–绑定到类

           
e、非绑定方法:静态方法:没有设置默许参数,并且能够被类和对象(不推荐)调用—–非绑定

    1陆 、接口类与抽象类

             a、 接口类:(在抽象类的底蕴上)

         在python中,暗许是不曾接口类的           

                    接口类不可能被实例化(借使实例化会报错)

          接口类中的方法不可能被完毕

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

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

           b、抽象类

在python中,默认是有的

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

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

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

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

抽象类和接口类的使用:

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

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

 

艺术的重写

 

父类里部分艺术,在子类里再次达成

   self 是1个样式参数,当执行 obj1 = Foo(‘wupeiqi’, 18 ) 时,self
等于 obj1

二 、继承的三种用途:

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

b:继承基类的形式,并且做出自个儿的改观可能扩大(代码重用)

 

a:申明有些子类包容于某基类,定义3个接口类Interface,接口类中定义

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

了一些接口名(正是函数名)且并未实现接口的效能,子类继承接口类,并且达成接口中的功用

  在内存里好像于下图来保存。

b、封装

 

1、优点:

威尼斯人线上娱乐 11

a、将转移隔绝

 

b、封装使用

  3. 第三步:从某处调用被打包的内容

c、升高复用性

   调用被打包的剧情时,有两种景况:

d、进步安全性

    • 经过对象直接调用
    • 因此self直接调用

② 、封装原则:

  1> 通过对象直接调用棉被服装进的内容

a、将不必要对外提供的始末都掩藏起来

   上海体育场合显示了对象 obj1 和 obj2
在内部存款和储蓄器中保留的法子,根据保存格式能够如此调用被封

b、把质量都藏匿起来提供公共艺术对其访问

   装的始末:对象.属性名

③ 、私有变量和村办方法

class Foo:

    def __init__(self, name, age):
        self.name = name
        self.age = age

obj1 = Foo('wupeiqi', 18)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性

obj2 = Foo('alex', 73)
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性

a、在python中用双涂鸦的始发的的办法降属性隐藏起来(设置个人的)

 

property属性

 

property是一种独特的属性,访问它时会执行一段成效(函数)然后再次回到值

透过self直接调用被卷入的内容

c、多态:”多态指的是一类东西有各个形态(比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生进行的是放学操作,就算双方音信一点差距也没有于,然则实施的机能分裂)

   执行类中的方法时,须求通过self直接调用被包裹的剧情

多态指的是:一类玩意儿有八种情况

class Foo:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def detail(self):
        print self.name
        print self.age

obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18

obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78

python自带多态:

 

多态:同一类东西的有余动静

  4.
综合,对于面向对象的包裹来说,其实正是选拔构造方法将内容封装到
对象

python里随地都以多态,只是大家一般发现不了

   中,然后经过对象直接可能self直接获取被包裹的剧情

操作的时候不供给关切那一个指标的数据类型,你即使用就行了

 

15、反射

 

壹 、反射:能够用字符串的措施去拜访对象的质量,调用对象的艺术(不过无法去拜谒方法),python中全数皆对象,都足以接纳反射。

五, 封装性与扩张性

② 、反射有各个方法:

  1.
封装在于鲜明区分内外,使得类完毕者能够修改封装内的事物而不影响外部调用者的

hasattr:hasattr(object,name)判断二个对象是或不是有name属性也许name方法。有就重回True,没有就回来False

   代码;而外部使用者只了然贰个接口(函数),只要接(函数)名、参数不变,使用者的

getattr:获取对象的性质可能措施,假诺存在则打字与印刷出来。hasattr和getattr配套使用

   代码永远无需变更。那就提供一个优异的合营基础——大概说,只要接这几个基础约定

要求留意的是,若是回到的是指标的法子,再次来到出来的是目的的内部存款和储蓄器地址,要是急需周转这些形式,可以在背后添加一对()

   不变,则代码改变不足为虑.

setattr:给指标的质量赋值,若属性不存在,先成立后赋值

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口,隐藏了内部的实现细节,此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能
>>> r1.tell_area()

delattr:删除该指标钦点的四个个性

 

a、内置方法:isinstance和issubclass

 

isinstance(obj,cls)检查是或不是obj是不是是类 cls 的靶子

六, 面向对象结构分析

class Foo: passclass Son(Foo): passs=Son()print(isinstance(s,Son))

  

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

  1.  如下边包车型大巴图所示:面向对象全体大概分两块区域:

class Foo(object): pass

 

class Bar(Foo): pass

威尼斯人线上娱乐 12

issubclass(Bar, Foo)

  那么种种大区域又足以分为多个小一些

c、python面向对象中的反射:通过字符串的花样操作对象相关的属性,python中漫天事物都以目的(都得以用反射)

class A:

    company_name = '老男孩教育'  # 静态变量(静态字段)
    __iphone = '1353333xxxx'  # 私有静态变量(私有静态字段)


    def __init__(self,name,age): #普通方法(构造方法)

        self.name = name  #对象属性(普通字段)
        self.__age = age  # 私有对象属性(私有普通字段)

    def func1(self):  # 普通方法
        pass

    def __func(self): #私有方法
        print(666)


    @classmethod  # 类方法
    def class_func(cls):
        """ 定义类方法,至少有一个cls参数 """
        print('类方法')

    @staticmethod  #静态方法
    def static_func():
        """ 定义静态方法 ,无默认参数"""
        print('静态方法')

    @property  # 属性
    def prop(self):
        pass

反省是否带有某属性—hasattr 再次回到布尔值

 

取得属性—getattr 没有就会报错

  2. 面向对象的公有私有 

安装属性—setattr

   1>  对于每3个类的分子而言都有二种样式:

除去属性—delattr

    •  公有成员,在其余地点都能访问
    •  私有成员,唯有在类的里边才能方式

d、内置方法:__del__

 

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

      2> 私有成员和国有成员的拜会限制分歧:

注:此格局一般不要定义,因为Python是一门高级语言,程序员在使用时无需关心内部存储器的分配和刑释,因为此工作都以交由Python解释器来实施,所以,析构函数的调用是由解释器在举行垃圾回收时自动触发执行的。

    静态字段(静态变量)

class Foo: def __del__(self): print(‘fgs’)

    •  公有静态字段:类能够访问;类内部能够访问;派生类中得以访问
    •  私有静态字段:仅类内部能够访问;

    class C:

    name = "公有静态字段"
    
    def func(self):
        print C.name
    

    class D(C):

    def show(self):
        print C.name
    

f=Foo()print(123)print(123)del fprint(123)print(123)print(123)

C.name         # 类访问

obj = C()
obj.func()     # 类内部可以访问

obj_son = D()
obj_son.show() # 派生类中可以访问

e、内置方法:item种类

 

__getitem__\__setitem__\__delitem__

class C:

    __name = "私有静态字段"

    def func(self):
        print C.__name

class D(C):

    def show(self):
        print C.__name


C.__name       # 不可在外部访问

obj = C()
obj.__name  # 不可在外部访问
obj.func()     # 类内部可以访问   

obj_son = D()
obj_son.show() #不可在派生类中可以访问  

__new__

 

class A: def __init__(self): #有三个艺术在帮你创造self

 

print(‘in init function’)

  3. 属性

self.x=1 def __new__(cls, *args, **kwargs): print(‘in init
funct’) return object.__new__(A,*args,**kwargs)

*  1>
property是
一*种特殊的属性,访问它时会执行一段功能(函数)然后再次来到值

a=A()

例一:BMI指数(bmi是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)

成人的BMI数值:
过轻:低于18.5
正常:18.5-23.9
过重:24-27
肥胖:28-32
非常肥胖, 高于32
  体质指数(BMI)=体重(kg)÷身高^2(m)
  EX:70kg÷(1.75×1.75)=22.86

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)

f、__str__和__repr__变更目的的字符串显示

 

__str__,__repr__

  2> 为啥要用property

1⑤ 、内置方法

  将叁个类的函数定义成特色未来,对象再去行使的时候obj.name,根本无法察觉自身的name

a、静态方法和类措施

  是实践了二个函数然后计算出来的,那种天性的行使方法服从了合并访问的尺度

① 、类格局:有个暗中同意参数cls,并且能够直接用类名去调用,能够与类属性交互(也便是足以采纳类属性)

  由于新型类中负有三种访问情势,大家能够依照他们几性格子的拜访特点,分别将多少个方

② 、静态方法:让类里的不二法门直接被类调用,就如正规调用函数一样

  法定义为对同叁天性质:获取、修改、删除

b、类格局和静态方法的相同点:都得以直接被类调用,不须要实例化

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property    #将该方法伪装成一个属性,在代码级别上没有本质的提升,但是让其看起来很合理.
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter  #固定写法, 其中伪装的函数属性名,要修改的方法属性名和 @属性名.setter 要一致
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

c、类措施和静态方法的区别点:

 

类格局必须有二个cls参数表示这几个类,能够利用类属性

  4. 类方法:  @classmethod

静态方法不须求参数

    应用场景:

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

     (1), 类中微微措施是不要求传入对象,不要对象的上上下下事物

一般而言方法:暗中同意有3个self对象传进来,并且不得不被对象调用——-绑定到对象

     (2), 对类中的静态变量进行转移

类措施:私下认可有叁个cls对象传进来,并且能够被类和指标(不引进)调用—–绑定到类

     (3),
继承中,父类获得子类的长空(子类类名调用,类名传给cls,父类中则会获得子类地址)

e、非绑定方法:静态方法:没有设置暗中同意参数,并且能够被类和对象(不推荐)调用—–非绑定

      

1⑥ 、接口类与抽象类

class A:
    def func(self):# 普通方法
        print(self)

    @classmethod    #类方法
    def func1(cls)
        print(cls)


a = A()
a.func()    #对象调用的普通方法
A.func(a)    #类名调用的普通方法

A.func1()  #类方法:通过类名调用的方法,类方法中第一个参数约定俗成是 cls
                        #python自动将类名(类空间)传给 cls    

a、 接口类:(在抽象类的根底上)

  注意:对象调用类方法,cls 获得的是类自个儿

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

  

接口类无法被实例化(假设实例化会报错)

  5. 静态方法:  @staticmethod

接口类中的方法无法被实现

    优点: 1. 代码块清晰  2. 充实复用性  

接口相当于做约束,让上边包车型大巴类的措施都遵从接口类中付出的艺术去定义。如若接口类里面有些方法类里面没有,那么那么些类就不可能被实例化。(字面驾驭)

class  A :
    @staticmethod
    def func(self):
        print(33)

A.func()
#结果: 33

持续的第一种意义非凡重大。它又叫“接口继承”。

 

接口继承实质上是供给“做出2个美妙的空洞,这一个抽象规定了多个合营接口,使得外部调用者无需关怀具体细节,可并排的处理完结了一定接口的具有目的”——那在程序设计上,叫做归一化。

 

b、抽象类

七,  isinstance与issubclass

在python中,暗中同意是局地

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

父类的法子,子类必须贯彻

class A: pass

class B(A): pass

obj = B()
print(isinstance(obj,B))  #True  判断对象所属关系,包含所有继承关系,只要是
print(isinstance(obj,str))  #True
print(type(obj) is str)     #不包含继承系,只管一层

抽象类(父类)的点子可以被实现

 

抽象类和接口类的界别:接口类无法达成格局,抽象类能够完毕方式里面的内容

issubclass(sub, super)检查sub类是或不是是 super 类的派生类

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

class A: pass

class B(A): pass

abj = B()

print(issubclass(B,A)) #True  #判断类的继承关系

抽象类和接口类的利用:

 

当几个子类的父类有一致的作用供给被完毕的时候就用抽象类

八,反射

当多少个子类有雷同的效果,不过贯彻各分歧的时候就用接口类

   getattr  hasattr  setattr  delattr

威尼斯人线上娱乐 13

    hasattr : 判断类中是或不是留存要调用的变量或措施

    getattr : 可与hasattr 结合使用,若hasattr判断存在,则履行 getattr.

    getattr (空间名 , ‘空间内的变量’)  能够用作是对
空间名.空间内的变量 进行轮换

 

  1.
python面向对象中的反射:通过字符串数据类型的变量名来访问这些变量的值。python

   中的一切事物都以指标(都足以选择反射)

    类名反射 : 静态属性  类方法  静态方法

    对象反射 : 对象属性  方法  

    模块  :  模块中的方法

    本人模块中:

      import sys   mymodule =
[‘__main__’]   getattr(mymodule.’变量名’)

  

  2. 使用对象来反光:

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性  若能找到返回True,找不到返回False
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__)
print(obj.show_name(obj))

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

 

  3. 实用类来反光:

class Foo(object):

    staticField = "old boy"

    def __init__(self):
        self.name = 'wupeiqi'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print (getattr(Foo, 'staticField'))#调用静态字段 结果为 : old boy
print (getattr(Foo, 'func'))#调用函数,打印的是内存地址
print (getattr(Foo, 'bar')())#调用静态函数,结果为 : bar

威尼斯人线上娱乐 14

 

  4. 对脚下模块反射

  首先找到本人眼下文件所在的命名空间

  

import sys

def s1():
    print('s1')

def s2():
    print('s2')

 this_module = sys.modules[__name__]#获取当前模块的空间地址

hasattr(this_module, 's2')
getattr(this_module, 's2')

 

  5. 对任何模块反射

import sys


def s1():
    print('s1')


def s2():
    print('s2')

this_module = sys.modules[__name__] 

hasattr(this_module, 's1') 
getattr(this_module, 's2')

 威尼斯人线上娱乐 15

 

九, 内置方法(双下划线办法,魔术点子,类中的特殊措施)

     __名字__  类中的每3个双下划线办法都有她协调的与众不一样意义

   内置函数和松手药方法是有密切关联的

   全部的嵌入方法不须求再外部直接调用,而是用一些别样的停放函数或独特的语法来机关

   触发这么些内置方法

  1. __call__  对象前面加括号,触发执行。

     注:__init__格局的执行是由创设对象触发的,即:对象 = 类名()
;而对此 __call__ 方法的

   执行是由对象后加括号触发的,即:对象() 或然 类()()

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

 

  2. __len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)  #__len__方法return的值就是len函数的返回值
a = A()
print(len(a))  #len(obj)相当于调用了这个对象的__len__方法,如果obj对象没有__len__方法
            那么len函数就会报错

 

  3.__new__

   构造方法  :__new__

   开始化方法: __init__

  1>  面向对象在实例化时:

   1.开拓2个空中,属于对象的  2.
把对象空间传给self,执行init,封装属性

   3. 将以此目的空间重临给调用者

  2>  __new__开拓空间,重返给self,
在实例化对象之后,__init__之前,执行__new__方法.

class SIngle:
        def __new__(cls,*args,**kwargs):
                print('在new方法里')
                obj=object.__new__(cls)
                print('在new方法里',obj)
                return  obj
         def __init__(self):
               print('在init方法里',self)

obj=SIngle()

  3> 单例类

   若是一个类,从头到尾只好有贰个实例,表达只开辟一块属于对象的上空,那么那么些类便是一

    个单例类

class A:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:#不空则执行下面程序,若为空则不执行,即只开辟一次空间
           cls.__instance=object.__new__(cls)#调用object类中的__new__方法,开辟一个空间
        return cls.__instance#返回空间地址
    def __init__(self,name,age):#把空间地址传给self
        self.name=name
        self.age=age

s1=A('he',23)
s2=A('ha',30)#返回的还是第一次开辟的空间,只是s2的属性将会覆盖原来的属性
print(s1.name)
print(s2.name)
#结果:  ha ha

 

  4.  __str__

  若是八个类中定义了__str__格局,那么在打印 对象
时,暗中同意输出该方法的归来值.

class A:
    def __init__(self):
        pass
    def __str__(self):
        return '白'
a = A()
print(a)    #相当于调用a的__str__方法
print('%s' % a)#相当于执行a.__str__方法

另:print(str(obj))  #内置的数据类型相当于执行obj.__str__方法

 

  5. __repr__ :

    1> __repr__ 是__str
__的备胎,如果有__str__主意,那么 print, %s,  str 都去实践str方法,

      并且使用str的再次回到值;假诺没有__str__,那么print, %s,
str都会履行repr

      repr(obj)  %r 

     2>
在子类中采纳__str__,先找子类的__str__,没有的话要向上找,只要父类不是object,就

      执行父类的__str__,不过即使出了object之外的父类都不曾__str__方式,就实施子类的

      __repr__办法,如若子类也尚未,还要进步继续找父类中的__repr__格局,一贯找不到

      再执行object类中的__str__的方法

class A:
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return '**%s**' % self.name
    def __repr__(self):
        return self.name
a = A('alex')
print(a)
print(str(a),repr(a))
print('%s , %r' % (a,a))


#注意:
# %r : 把 repr 的返回结果给 %r;
# %s :把 str 的返回结果给 %s

 

  6. getattr(object, name[default])  

  获取对象object的属性只怕措施,假如存在打字与印刷出来,假使不存在,打字与印刷出暗中认可值,暗中认可值

  可选。须求留意的是,倘若是回去的靶子的主意,重临的是方法的内部存储器地址,假诺急需周转

  那么些艺术,能够在背后添加一对括号。

>>> class test():
...     name="xiaohua"
...     def run(self):
...             return "HelloWord"
...
>>> t=test()
>>> getattr(t, "name") #获取name属性,存在就打印出来。
'xiaohua'
>>> getattr(t, "run")  #获取run方法,存在就打印出方法的内存地址。
<bound method test.run of <__main__.test instance at 0x0269C878>>
>>> getattr(t, "run")()  #获取run方法,后面加括号可以将这个方法运行。
'HelloWord'
>>> getattr(t, "age")  #获取一个不存在的属性。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: test instance has no attribute 'age'
>>> getattr(t, "age","18")  #若属性不存在,返回一个默认值。
'18'
>>>

  

  7. setattr(object, name, values)

  给目的的习性赋值,若属性不存在,先创设再赋值.

>>> class test():
...     name="xiaohua"
...     def run(self):
...             return "HelloWord"
...
>>> t=test()
>>> hasattr(t, "age")   #判断属性是否存在
False
>>> setattr(t, "age", "18")   #为属相赋值,并没有返回值
>>> hasattr(t, "age")    #属性存在了
True
>>>

 

  8. item 文山会海: 和对象使用 [ ] 访问值有关联

    __getitem__

class B:
  #def __init__(self,lis):
    #self.lis = lis
  def __getitem__(self,item):
    return  getattr(self,item)
    #return self.lis[litem]
  def __setitem__(self,key,value):
    setattr(self,key,value)
    #self.lis[key] = vslue
  def __delitem__(self,key):
    delattr(self,key)
    #self.lis.pop(key)

b = B()

b['k'] = 'v1'  #触发__setitem__
print(b['k1']) #  __getitem__
del b['k1']   #  __delitem__

#b = B(['11','22','33','44'])
#print(b.lis[0])
#B[3] = '99'
#print(b.list)
#del b[2]
#print(b.lis)

 

  9. hash方法

   底层数据结构基于hash值寻址的优化操作

   hash是三个算法能够把某3个要设有内部存款和储蓄器里的值通过一名目繁多总结,保险不一样值hash

   值的结果不一致.

   对通1个值数十四回履行的python代码的时候hash值的结果是差异的,不过对通三个值

   再痛1回施行python代码的时候hash值永远不变. 

class Employee:
    def __init__(self,name,age,sex,partment)
        self.name=name
        self.age=age
        self.sex = sex
        self.partment = partment
    def__hash__(self):            #筛选hash值相等
        return hash('%s%s' % (self.name,self.sex))
    def __eq__(self,other):        #筛选值相等
        if self.name == other.name and self.sex == other.sex
            return True
    employ_lst = [...]
    for i in range(200)
            employ_lst.append(Employee('alex',i,'male','python'))
     for i in range(200)
            employ_lst.append(Employee('wusir',i,'male','python'))  
    for i in range(200)
            employ_lst.append(Employee('taibai',i,'male','python'))    
employ_lst = set(employ_lst)
for person in employ set :
    print(person.__dic__ )


#set集合的去重原理

  10. eq 方法

class A :
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __eq__(self,other):
        if self.name == other.name and self.age == other.age:
            return True

a = A('小白',88)
aa = A('大白'99)
aaa = A('超大白',100)

print(a,aa)
print(a == aa == aaa)     # == 这个语法是完全和__eq__相关

 

  11. 析构方法  

    释放八个空间

    归还/释放部分在创制对象的时候借用的一部分能源

class A :    
    def __del__(self):   #析构方法 del A的对象 会自动触发这个方法 
        print('饿了吗')
a = A()
del a    #对象删除 del    当不主动进行该操作时,python解释器在程序执行
                #完后也会自动触发 __del__ 函数(垃圾回收机制).
print(a)        

 

 

    

   

 


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图