面向对象

1.定义类

class Person:
    """
    定义类 Person
    """
    # 属性
    #构造方法,初始化对象
    def __init__(self):
        self.name="tom"
        self.age=20
        self.gender=u"男"
    # str toString()方法
    def __str__(self):
        return "name:%s"%self.name
    # 方法
    def say(self):
        print("saying...")

2.实例化对象

3. 隐藏属性 【属性私有化】 set，get

class Dog:
    def __init__(self,name):
        self.__name=name
    def __str__(self):
        str="[name:%s]"%(self.__name)
        return str
    
    def set_name(self,name):
        self.__name=name
    def get_name(self):
        return self.__name

　　将属性名称命名为：__name，即该属性被私有化了，不能通过对象直接访问。

4.私有方法

__methodName()

5.__del__方法：【析构函数】

class Dog:
    def __init__(self,name):
        self.__name=name
    def __str__(self):
        str="[name:%s]"%(self.__name)
        return str
    
    def set_name(self,name):
        self.__name=name
    def get_name(self):
        return self.__name

dog1=Dog("hei")
dog2=dog1
dog1.set_name("xiaohei")

　　如果del dog1，仅仅是删除dog1的变量的指向；dog1指向的对象仍然存在，此时不会执行析构函数

　　如果对象没有人引用了，即dog1,dog2都被删除【引用计数为0】，就会执行析构函数.

　　如果程序退出，也会执行析构函数。

　　计算引用计数：sys.getrefcount(object) 比实际多一个，传参时，生成一个新的变量

6.继承

定义：

class Animal:
    def eat(self):
        print("eating..")
    
    def play(self):
        print("playing..")


class Dog(Animal):
    def dark(self):
        print("dog eating...")

class Cat(Animal):
    def catch(self):
        print(u"抓老鼠...")

dog1=Dog()
dog1.eat()
dog1.dark()

cat1=Cat()
cat1.eat()

　　

　　多层继承：

class LangDog(Dog):
    def eatFood(self):
        print(u"狼行天下吃肉")

构造函数：

　　调用父类的构造方法：

def __init__(self,grade,name,age):
    # Person.__init__(self,name,age)   ****
    super(Student,self).__init__(name,age)
    self.grade=grade

调用父类成员：

　　方法：

class LangDog(Dog):
    def eatFood(self):
        print(u"狼行天下吃肉")
        #调用父类方法
        Dog.dark(self)    #父类名.方法名(self)
　　　　# super().dark() #python3
　　　　　Animal.eat(self)   #父类的父类

私有成员【属性和方法】的继承：

　　私有成员在子类中访问不到，必须通过公共接口访问。

　　对于共有成员，子类完全继承【子类和子类对象都可以访问】

 7.多继承

 　　类默认继承object类（python3），

class A（object）:
    def fun(self):
        print("method A ....")


class B:
    def fun(self):
        print("method B")

class Sub(B,A):
    aa=12

s=Sub()
s.fun()

　　如果A、B中有相同的方法名，子类默认调用前面父类的方法

　　方法解析顺序：查看某个类的成员的访问优先级（搜索）

　　　　Sub.__mro__     python3

　　　　import inspect

　　　　inspect.getmro(Sub)     python2

(<class '__main__.Sub'>, <class __main__.B at 0x0000000004B67C48>, <class '__main__.A'>, <type 'object'>)

　　在设计程序中，最好不要写重名函数，如果重名，应该使用 类名.方法

8.with

 with Person() as per:

　　pass

使用with的类必须实现__enter__,__exit__方法

class MyResource(object):
    name = 'name'
    def __enter__(self):
        print('连接资源..')
        return self
    # exc_type
    # exc_val
    # exc_tb
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_tb:
            print('exception..')
        else:
            print('no exception..')
        print('释放资源..')
        # with中发生了异常：如果返回false，with语句的外部会跑出异常
        return True

    def query(self):
        print('查询..')

with MyResource() as a:
    1/0
    a.query()