攻克python3-面向对象

面向对象编程——万物可分类，万物为对象

类：是对一类具有相同属性的对象的抽象集合、蓝图

如何定义一个类：

　　在python中，类的的定义分为两种

　　1.python2：class 类名:

　　　　　　　　　　......

　　　　　　　　　　......

　　2.python3：class 类名 (object)：

　　　　　　　　　　......

　　　　　　　　　　......

类变量：

　　类变量是这个类的属性，可以由类直接调用，也可以由实例调用，所有的实例共用同一个类变量，储存在类的内存空间中，在一个实例中调用或修改一个不可变类变量（整形、字符串）时，不会修改类变量的值，只是在实例中添加与类变量同名的实例变量，在实例中修改一个可变类变量（列表、字典），会修改类变量的值。

　　可变变量与不可变变量参考

对象：
对类进行实例化，形成具有该类属性的一个具象
    实例变量：
        静态属性，作用域为当前实例本身，保存在实例的内存中，不能通过类来调用，只能通过实例来调用、
    构造函数( __init__ )：
        具有初始化作用，实例化一个对象时，会自动执行构造函数
    析构函数( __del__ )：
        在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作， 如关闭一些数据库连接，关闭打开的临时文件
    方法：
        动态属性，对象可以实现的功能
    私有属性和私有方法：
        在属性名或方法名前加上__，私有属性和私有方法只能在对象内部使用
    受保护属性：
        在属性名或方法名前加上_，只允许其本身与子类进行访问

 

类的特性
    封装：
        把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏.
    继承：
        可以使用现有类的所有功能，并且无需重新编写原来类的情况下对功能进行扩展.代码复用
        要是实现继承，要通过"继承" 和“组合”来实现
        组合就是在一个类中实例化父类
        多继承：
            在python3中，经典类与新式类都按广度优先继承(多继承存在的问题太多，如果需要继承多个类，建议使用组合)

class Animal(object):
    str1= "abc"
    int1=12
    list1=[1,2,3,4]
    dict1={1:'a',2:'b'}
    '''类变量'''

    def __init__(self,name,age):
        #构造函数,初始化实例
        self.name=name
        self.age=age
        self.__flag=1  #私有属性
        self._count=1

    def __del__(self):
        #析构函数
        print("%s被杀了"%self.name)

    def __self(self):
        #私有方法
        print("我是私有方法")

    def eat(self,food):#方法，功能，动态属性
        if self.__flag==1:
            print("%s is eating %s"%(self.name,food))

    def sleep(self):
        self.__self()
        print("%s is sleepping "%self.name)

    def _foo1(self):
        print("我是父类的受保护方法")

class Dog(Animal):
    def __init__(self,name,age,sex,size):
        super(Dog,self).__init__(name,age)
        self.sex=sex
        self.size=size
        self._count1=2

    def talk(self):
        print("wolf wolf!")

    def _foo2(self):
        print("我是子类的受保护方法")

# 组合，但是需要通过类里所包含的类进行调用
class Cat(object):
    def __init__(self,name,age,color):
        self.animal=Animal(name,age)
        self.color=color

    def talk(self):
        print("mia mia!")


d1=Dog("wr",12,"w",30)
c1=Cat("lbw",9,"black")

d1.sleep()
d1._foo1()
print(d1._count)

c1.animal.sleep()

继承

 

    多态：
        一种接口，多种表现形式

class Animal:
    def __init__(self, name):
        self.name = name

    def talk(self):
        pass

    @staticmethod
    def animal_talk(obj):
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('Meow!')


class Dog(Animal):
    def talk(self):
        print('Woof! Woof!')


d = Dog("陈荣华")
#d.talk()

c = Cat("徐良伟")
#c.talk()
#
# def animal_talk(obj):
#     obj.talk()

Animal.animal_talk(c)
Animal.animal_talk(d)

多态

 

 

静态方法：
    静态方法就是一个普通方法，需要实例化对象作为参数，但是不能调用实例变量与类变量，与类唯一的联系就是需要通过类名来调用这个方法，所以
    只是名义上归类管。私有方法不能作为静态方法,但受保护类可以作为静态方法

class Dog(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    @staticmethod #静态变量
    def __talk(self):
        print("wolf wolf!")

    @staticmethod
    def _foo2(self):
        print("我是子类的受保护方法")

d=Dog("wr",12)

Dog._foo2(d)

 

类方法：
    不用通过实例化，就可以直接调用，而且类方法只能访问类变量，不能访问实例变量.私有方法不能作为类方法,但受保护类可以作为类方法

class Dog(object):
    str2='asd'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    @classmethod
    def _talk(cls):
        print("wolf wolf!",cls.str2)

    @staticmethod
    def _foo2(self):
        print("我是子类的受保护方法")

Dog._talk()

 

属性方法：
    动态属性静态化

class Dog(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    @property
    def talk(self):
        print("wolf wolf!")

    @staticmethod
    def _foo2(self):
        print("我是子类的受保护方法")

d=Dog("wr",12)
d.talk

'''
好吧，把一个方法变成静态属性有什么卵用呢？既然想要静态变量，那直接定义成一个静态变量不就得了么？
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  0

    @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")

    @flight_status.setter
    def flight_status(self,status):
        # print("flight %s has changed status to %s" %(self.flight_name,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")

    @flight_status.deleter
    def flight_status(self):
        print("1")

f = Flight("CA980")
f.flight_status
f.flight_status = 2
del f.flight_status
f.flight_status=3

属性方法实例

 

 1 class Animal(object):
 2     str1= "abc"
 3     int1=12
 4     list1=[1,2,3,4]
 5     dict1={1:'a',2:'b'}
 6     '''类变量'''
 7 
 8     def __init__(self,name,age):
 9         #构造函数,初始化实例
10         self.name=name
11         self.age=age
12         self.__flag=1  #私有属性
13 
14     def __del__(self):
15         #析构函数
16         print("%s被杀了"%self.name)
17 
18     def __self(self):
19         #私有方法
20         print("我是私有方法")
21 
22     def eat(self,food):#方法，功能，动态属性
23         if self.__flag==1:
24             print("%s is eating %s"%(self.name,food))
25 
26     def sleep(self):
27         self.__self()
28         print("%s is sleepping "%self.name)
29 
30 #类名()，实例化一个对象，并且返回对象的地址
31 dog=Animal("d",11)
32 cat=Animal("c",9)
33 
34 #调用类变量
35 print("调用类变量:")
36 print(Animal.list1)
37 
38 #调用实例变量,不能通过类调用实例属性
39 print("调用实例变量:")
40 print(dog.name)
41 print(cat.age)
42 
43 #通过实例调用类变量
44 print("通过实例调用类变量:")
45 print(cat.str1)
46 print(dog.list1)
47 
48 #通过实例修改不可变类变量
49 print("通过实例修改不可变类变量")
50 print("修改前:")
51 print(Animal.str1)
52 print(dog.str1)
53 print(cat.str1)
54 dog.str1="phk"
55 print("修改后:")
56 print(Animal.str1)
57 print(dog.str1)
58 print(cat.str1)
59 
60 
61 #通过实例修改可变类变量
62 print('通过实例修改可变类变量')
63 print("修改前:")
64 print(Animal.list1)
65 print(dog.list1)
66 print(cat.list1)
67 cat.list1.append(12)
68 print("修改后:")
69 print(Animal.list1)
70 print(dog.list1)
71 print(cat.list1)
72 
73 #通过对象调用对象的方法
74 print("通过对象调用对象的方法:")
75 dog.eat("肉")
76 cat.sleep()
77 
78 #通过类调用对象函数
79 print('通过类调用对象函数:')
80 Animal.sleep(dog)

类与实例互相调用对方属性