澳门至尊网站-首页

您的位置:澳门至尊网站 > 程序编程 > 面向对象2,python类和对象

面向对象2,python类和对象

2019-10-19 03:02

成员和嵌套(组合)

面向对象 Object Oriented Programing


成员

类的特色

  • 封装
  • 1、防止数据被私自改动
  • 2、使表面程序不供给灌溉对象内部的构造,只要求经过此目的对外提供的接口进行直接访问就可以

  • 继承

  • 1、类能够派生出子类
  • 2、父类里定义的属性、方法自动被子类承接
  • 3、通过父类=>子类的方法以微小代码量的法子完结不一样角色的共同点和差别点同一时间设有

  • 多态

  • 三个接口,两种兑现;父类派生出分歧的子类,子类在持续父类的千篇一律方法同有的时候间又对父类的艺术做了分歧的落到实处,那也等于同样种东西表现出的有余形状。
  • 例:人类是一个父类,派生出中中原人、葡萄牙人、奥地利人等子类,子类继承使用talk()方法,但分裂人所说语言分歧,talk()方法依据不一样人展现出差异的攀谈语言(汉语、德文...)。
  • 即对不相同对象发出的新闻将会有不一致的表现。举个例子:COO只要发生信息(职业),不一致的职员和工人对象将会按自身的意义开展分化的工作。

1.类的成员:变量,方法,属性

变量:

  实例变量(字段)

    公有实例变量(字段)

1 class Foo:
2     def __init__(self,name):
3         self.name = name#公有实例变量
4     
5      def func(self):
6         return self.name

 

    私有实例变量(字段)

1 class Foo:
2     def __init__(self):
3         pass
4     def __func(self):
5         print("私有实例变量")
6 
7 obj = Foo()
8 obj.func()#此处无法调用

 

  类变量(静态字段)

    公有类变量(静态字段)

 1 class Foo:
 2     a = 1#公有类变量
 3     def __init__(self):
 4         pass
 5     def func(self):
 6         return self.a
 7 
 8 obj = Foo()
 9 print(obj.a)
10 print(Foo.a)

 

    私有类变量(静态字段)

1 class Foo:
2     __a = 1
3     def __init__(self):
4         pass
5     def func(self):
6         print(self.a)#不能引用,错
7 
8 obj = Foo()
9 obj.func()

总结:

  公有实例变量可以在类的法子中应用,也得以用实例化的指标调用

  私有实例变量无法在目的调用,只可以在类中用别样措施调用后,再使用对象调用

  公有类变量能够在类中调用,也能够用对象调用

  私有类变量只好在类中动用别的事办公室法调用,无法应用对象调用,子类也无法调用(要是非得要用,先在父类中使用办法来调用这几个私有类变量,再在子类中调用那几个法子)

 

方法:

  实例方法

  

1 class Foo:
2     def __init__(self,name):
3         self.name = name
4     def func(self):#实例方法
5         print(self.name)
6 
7 obj = Foo("abc")
8 obj.func()

 

  静态方法

1 class Foo:
2     def __init__(self,name)
3         self.name = name
4     @staticmethod#静态方法
5     def display(a1,a2):
6         return a1 + a2
7 
8 Foo.display(1,2)
#如果无需使用对象中封装的值,就可以使用静态方法

 

  类方法

1 class Foo:
2     @classmethod
3     def show(cls,x1,x2):#默认第一个参数是类(cls)
4         print(cls,x1,x2)
5 
6 ret = Foo.show(1,2)
7 print(ret)

总结:

  实例方法:至罕见叁个参数,第三个参数必得是实例对象,暗中同意是self

  静态方法:能够没有参数,也无需使用对象中封装的值,方法方面需求加@staticmethod

  类方法:至稀有二个参数,第一个参数必须是类,暗许是cls,方法方面必要加@classmethod

 

性格(通过措施退换出来):

  

 1 class Foo:
 2     def __init__(self):
 3         pass
 4     @property
 5     def start(self):
 6         return 1
 7     @property
 8     def end(self):
 9         return 2
10 
11 obj = Foo()
12 print(obj.start)
13 print(obj.end)

小结:属性编写时,方法方面写@property,方法中独有叁个参数self

  调用时,没有供给加括号,直接是对象.方法

  对于简易的主意,当无需传参且有重回值时,能够采用性质

 

类的定义

class class_name(object):
    attr_name = value #类的公有属性,静态字段
    def __init(self,参数1,参数2...):#构造函数,初始化实例时执行
        self.name = 参数1
        ...#类的属性,成员属性,普通字段

    def func(self,参数1,参数2...):#类的方法
        pass

    def __del__(self):#析构函数,实例销毁时执行
        pass

嵌套(组合):

 1 class Student(object):
 2     def __init__(self,name,age)
 3         self.name = name
 4         self.age = age
 5 #创建三个人
 6 obj1= Student("a",18)
 7 obj2= Student("b",20)
 8 obj3= Student("c",21)
 9 
10 class School(object):
11     def __init__(self,name,address)
12         self.name = name
13         self.address = address
14 
15 #创建三个学校
16 s1 = School("学校1","北京")
17 s2 = School("学校2","上海")
18 s3 = School("学校3","深圳")
19 
20 
21 #给每个学生分配学校
22 obj1.school = s1
23 obj2.school = s2
24 obj3.school = s3
25 
26 print(obj1.school.name)
27 print(obj2.school.name)
28 print(obj3.school.name)

 

类的实例化

var1 = class_name(参数1,参数2...)#这里传入构造函数中形参的实参

类的民用属性

self.__attrname用五个下划线开始定义为私有质量,只在类的中间能够访谈

只读访问私有属性

  • 在类中定义二个办法重返此属性,对表面提供只读访谈接口

    def get_attrname(self)
    return self.__attrname
    
  • 强制访问(不要这么做)
    实例后跟‘.’,接三个下划线,接类名,接多个下划线的私家属性

    var1 = class_name()
    var1._class_name__attrname
    

类的国有属性

var1 = class_name(参数1,参数2)
var2 = class_name(参数1,参数2)
#上文定义类中,var1.name和var2.name是根据实例化时传入的参数1而不同,因此叫做成员属性
#上文中在__init__前定义的attr_name则是公有属性,由每个实例共享

#更改类的公有属性
var1.attr_name = new_value#通过实例去修改,修改的是实例自己的公有属性
#此时print(var1.attr_name)  值发生改变,print(var2.attr_name)  值未改变

class_name.attr_name = new_value#通过类更改,修改的是所有以这个类实例化的对象的公有属性
#此时print(var1.attr_name)  ,print(var2.attr_name)  值均已改变,且均为new_value

面向对象编制程序(OOP)语言的八个最首要成效正是【承袭】

  • 此伏彼起是指派用现存类的富有机能,不须要编写原本的类而开展那一个功能的扩张
  • 通过接二连三创设的新类称为【子类】或【派生类】
  • 被持续的类称为【父类】、【基类】或【超类】
  • 接二连三能够经过【传承】(Inheritance)和【组合】(Composition)来贯彻
  • 在好几OOP语言中,二个子类能够三番五次多个基类。但日常景象下,三个子类只持续一个基类,要落到实处多种承袭,能够通过种类继承来促成。

此伏彼起的实现方式有二种

  • 福寿双全一连
  • 采用基类的习性方法没有要求额外编码
  • 接口承继
  • 仅使用基类的性质和方法名称,但子类必需重构基类方法

在挂念使用持续时,需求注意四个类之间应当是【属于】关系


继承

class class_name(object):
    def __init__(self,name,age):
        pass

    pass

#子类
class sun_class_name(class_name):
    def __init__(self,name,age,参数1...)#先继承,再重构,
        class_name.__init__(self,name,age)#继承父类构造方法
        #super(sun_class_name,self).__init__(name,age) #新式类写法
    pass
  • 子类构造函数假使重构,则先接二连三父类构造函数,再重构
  • 子类承接父类的性质和模式,尽管重构方法,使用重构后措施

新式类和出色类

  • 新式类和经文类在python3中都以广度查找来接二连三
  • 后续写法

    class_name.init(self,name,age)#继承父类构造方法 #super(sun_class_name,self).init(name,age) #新式类写法

封装

  • 类中封装了字段(属性)和办法
  • 指标(实例)中封装了:普通字段的值

an example(组合包装)

class F1(object):
    def __init__(self,n):
        self.N = n
        print("F1")

class F2(object):
    def __init__(self,arg1):
        self.a =arg1
        print("F2")

class F3(object):
    def __init__(self,arg2):
        self.b =arg3
        print("F3")

#实例化
o1 = F1("lmc")
o2 = F2(o1)
o3 = F3(o2)

#s输出'lmc'
o1.b.a.N

继承

class F1:
    def __init__(self):
        pring("F1")
    def a1(self):
        print("F1a1")

class F2(F1):
    def __init__(self):
        pring("F2")
    def a1(self):
        print("F2a1")

class F3(F2):
    def __init__(self):
        pring("F3")
    def a1(self):
        print("F3a1")

#实例化
obj = F3()
#当执行obj.a1()时,因F3重构了a1()方法,此时调用F3.a1()
obj.a1()->>"F3a1"

class F1:
    def __init__(self):
        pring("F1")
    def a1(self):
        print("F1a1")
    def a2(self):
        print("F1a2")

class F2(F1):
    def __init__(self):
        pring("F2")
    def a1(self):
        self.a2()
        print("F2a1")
    def a2(self):
        print("F2a2")

class F3(F2):
    def __init__(self):
        pring("F3")
    def a2(self):
        print("F3a2")

#实例化
obj = F3()
#当执行obj.a1()时,因F3未重构了a1()方法;F2重构了a1(),此时调用F2.a1(),
#此时F2.a1()中第一句调用self.a2(),self即调用方法本身的对象F3,所以执行本身的F3.a2()
#在父类里的self是当前调用方法对象,因obj->F3实例化后的指向是F3,所以为最底层的F3
obj.a1()--->>"F3a2" [换行] "F2a1"

静态方法

  • 字段
  • 常常字段/普通属性(保存在实例化的指标中)
  • 静态字段/静态方法(保存在类中)

  • 方法

  • 常常性方法(保存在类中,实例化的目标进行调用,起码有多个self参数)
  • 静态方法(保存在类中,调用者-》类(没有需要创设对象),能够有专擅参数):

    class F1:

    @staticmethod
    def a1(self):#静态方法self参数不是必须
        print("F1A1")
    

    F1.a1()直接调用,不必实例化。


类的主意

构造方法

def __init__(self,arg1,arg2...)
    pass
  • 类实例化时一直调用,如有参数,实例化时索要同一时候传入参数

析构方法

def __del__(self):
    pass
  • 去除对象时(del class_name)或程序退出时调用

获得类的习性字典

查看类或对象中的全数成员

  • 类.__dict__,重返类的习性,以字典方式
  • self.__dict__

@staticmethod静态方法

  • 一定于把那么些符号下的点子断开和类的连年,和类没什么关系
  • 调用时间接class_name.func_name,能够不用实例化
  • 和类的无与伦比涉嫌是调用时必需运用类名作为前缀,名义上归类管
  • self参数没有要求

@classmethod类方法

  • 类格局只可以访问类变量,不能访谈实例变量
    ```python
    class A(object):
    name = 'alex'
    def __init_(self):
    self.name = 'wusir'

    @classmethod
    def test(self):
    print(self.name)

a=A()
a.test()
结果:alex
```

  • 因而类方法日常用于禁绝访问类的私房属性(实例化后的变量)
  • 当类的国有属性名和个人属性名同样期,类格局只好采访类的公有属性(类级变量)

@property属性方法

  • 把叁个类的措施成为贰个静态属性

    class A(object):

    def __init__(self):
        self.name = 'alex'
    
    @property
    def eat(self):
        print('%s is eating...'%self.name)
    

    a = A() a.eat#不可能加括号调用

  • 带参数的格局

    class A(object):

    def __init__(self):
        self.name = 'alex'
    
    @property
    def eat(self,food):
        print('%s is eating %s'%(self.name,food))
    
    @eat.setter
    def eat(self,food):
        print('set to food:',food)
    
a = A()
a.eat = 'baozi'
  • 能够将设置的参数用一个民用属性保存下去

  • 属性方法暗中同意无法像常常属性一样删除,能够用删除存款和储蓄的私人商品房属性来做二个剔除

    @eat.deleter
    def eat(self):
        del self.__food
    

好吧,把多个方法成为静态属性有如何卵用呢?既然想要静态变量,那直接定义成三个静态变量不就得了么?well, 以往您会需到非常多情形是不能轻便通过 定义 静态属性来贯彻的, 举个例子,你想精通叁个航班当前的景观,是达到了、延迟了、撤消了、照旧曾经飞走了, 想知道这种场馆你必需经历以下几步:

  1. 连续几天航空公司API查询

  2. 对查询结果举行分析

  3. 再次回到结果给你的顾客

因此这一个status属性的值是一多种动作后才获得的结果,所以你每便调用时,其实它都要经过一层层的动作才回去您结果,但这几个动作进程不要求客商关切, 客户只要求调用那本性子就能够,领悟 了么?

class Flight(object):

    def __init__(self,name):

        self.flight_name = name





    def checking_status(self):

        print("checking flight %s status " % self.flight_name)

        return  1



    @property

    def flight_status(self):

        status = self.checking_status()

        if status == 0 :

            print("flight got canceled...")

        elif status == 1 :

            print("flight is arrived...")

        elif status == 2:

            print("flight has departured already...")

        else:

            print("cannot confirm the flight status...,please check later")





f = Flight("CA980")

f.flight_status



航班查询

类的特别成员方法

__doc__ 表示类的叙说音信

class Foo:
    """ 描述类信息,这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出:类的描述信息

__module____class__

  • __module__ 表示最近操作的指标在老大模块
  • __class__ 表示最近操作的对象的类是哪些

    class C:

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

    #---------------------------- from lib.aa import C obj = C() print obj.module # 输出 lib.aa,即:输出模块 print obj.class # 输出 lib.aa.C,即:输出类

__call__目的后边加括号,触发实践

class Foo:

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

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

__str__ 假如一个类中定义了__str__情势,那么在打字与印刷 对象 时,暗中认可输出该措施的再次来到值

class Foo:

    def __str__(self):
        return 'alex li'


obj = Foo()
print obj
# 输出:alex li

__getitem____setitem____delitem__

用于索引操作,如字典。以上分别表示收获、设置、删除数据

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__',key)

    def __setitem__(self, key, value):
        print('__setitem__',key,value)

    def __delitem__(self, key):
        print('__delitem__',key)

 obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'alex'   # 自动触发执行 __setitem__
del obj['k1']  

__new__详解:

参照文书档案

本文由澳门至尊网站发布于程序编程,转载请注明出处:面向对象2,python类和对象

关键词:

  • 上一篇:没有了
  • 下一篇:没有了