成员和嵌套(组合)

类的定义

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

一丶字段

成员

@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
“`

  • 因此类方法一般用于禁止访问类的私有属性(实例化后的变量)
  • 当类的公有属性名和私有属性名一致时,类方法只能访问类的公有属性(类级变量)

  字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同.

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

  调用时,无需加括号,直接是对象.方法

  对于简单的方法,当无需传参且有返回值时,可以使用属性

 

__str__ 如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值

class Foo:

    def __str__(self):
        return 'alex li'


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

  方法包括普通方法丶静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同

嵌套(组合):

 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)

 

@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



航班查询

  上面我们看到的两种字段都是公有字段,下面为私有字段

class Foo:    #类变量    country = "你好"    #私有类变量    __ctorens = "再见"    def __init__(self,name,phone):        # 实例变量        self.name = name        #私有示例变量        self.__phone = phone    def too:        print(Foo.__ctorens)#直接访问普通字段obj = Foo("李白","165136851546")obj.too()#直接访问静态字段print(Foo.country)#在类外面是没法访问类中的私有字段的,所以这里会报错print(Foo.ctorens)

图片 1

继承

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"

  由上述代码可以看出[普通字段需要通过对象来访问] [静态字段通过类访问],在使用上可以看出普通字段和静态字段的归属是不同的,其在内容的存储方式也不一样,静态字段在内存中只保存一份,普通字段在每个对象中都要保存一份

类的公有属性

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

  1.普通方法:由对象调用,至少一个self参数,执行普通方法时,自动将调用该方法的对象赋值给self

析构方法

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

  属性的定义时就是在普通方法的基础上添加@property装饰器,属性仅有一个self参数,调用时无需括号

class Foo:    def __init__:        pass    #属性在方法名前面加上@property    @property      def start:        return 1obj = Foo()print(obj.start)    #无需加括号,直接调用

只读访问私有属性

  • 在类中定义一个方法返回此属性,对外部提供只读访问接口

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

    var1 = class_name()
    var1._class_name__attrname
    

  两个类中的变量互相建立关系就叫嵌套

class School:    def __init__(self,name):        self.name = nameobj = School("舞蹈教室")obj1 = School("音乐教室")obj2 = School("美术教室")class Teacher:    def __init__(self,name):        self.name = namet = Teacher("舞蹈老师")t1 = Teacher("音乐老师")t2 = Teacher("美术老师")#############为老师分配教室t.School = objt1.School = obj1t2.School = obj2############查看t1老师所在的教室print(t1.School.name)

__doc__ 表示类的描述信息

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

    def func(self):
        pass

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

三丶属性

新式类和经典类

  • 新式类和经典类在python3中都是广度查找来继承
  • 继承写法

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

   3.静态方法:由类调用,无默认参数

# 实例方法class Foo:    def __init__(self,name):        self.name = name    #实例方法    def tom:        passobj = Foo("XX")obj.tom()#静态方法#在方法前面加@staticmethod,方法名中的self也不用写了,可以写任何参数,调用直接用  类名.方法名 调用class Foo:    def __init__(self,name):        self.name = name    #静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法    @staticmethod    def tom:        printFoo.tom(1,2)# 类方法#在方法前面加上@classmethod,方法名中参数必须有cls,cls是指类class Foo:    def __init__(self,name):        self.name = name    def show1:        print    # 类方法    @classmethod    def show:        print  #<class '__main__.Foo'> 1 2Foo.show

发表评论

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