攻克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

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  #私有属性

    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)

#类名()，实例化一个对象，并且返回对象的地址
dog=Animal("d",11)
cat=Animal("c",9)

#调用类变量
print("调用类变量:")
print(Animal.list1)

#调用实例变量,不能通过类调用实例属性
print("调用实例变量:")
print(dog.name)
print(cat.age)

#通过实例调用类变量
print("通过实例调用类变量:")
print(cat.str1)
print(dog.list1)

#通过实例修改不可变类变量
print("通过实例修改不可变类变量")
print("修改前:")
print(Animal.str1)
print(dog.str1)
print(cat.str1)
dog.str1="phk"
print("修改后:")
print(Animal.str1)
print(dog.str1)
print(cat.str1)


#通过实例修改可变类变量
print('通过实例修改可变类变量')
print("修改前:")
print(Animal.list1)
print(dog.list1)
print(cat.list1)
cat.list1.append(12)
print("修改后:")
print(Animal.list1)
print(dog.list1)
print(cat.list1)

#通过对象调用对象的方法
print("通过对象调用对象的方法:")
dog.eat("肉")
cat.sleep()

#通过类调用对象函数
print('通过类调用对象函数:')
Animal.sleep(dog)