Python面向对象（一）

先贴一段类的代码

class Animal(object):
    # 类属性
    type = 'Animal'
    # 私有类属性
    __count = 0

    def __init__(self, name, sex=True):
        # 实例属性
        self.name = name
        # 私有实例属性
        self.__sex = sex

        Animal.__count += 1

    def say(self):
        pass

    def __str__(self):
        return "I'm a %s,My name is %s, male:%s" % (self.type, self.name, self.__sex)


class Cat(Animal):
    # 类属性
    type = 'Cat'

    def __init__(self, name, sex=True):
        super().__init__(name=name, sex=sex)

    def say(self):
        print("miao miao miao")


if __name__ == '__main__':
    cat1 = Cat('mimi')
    cat2 = Cat('mama')
    cat1.say()
    print(cat1)

    print(isinstance(cat1, Cat), isinstance(cat1, Animal), type(cat1))

    # 访问实例属性
    print(cat1.type)
    # 修改实例属性
    cat1.type = 'cat1'
    # 访问修改后的实例属性
    print(cat1.type)

    # 访问类属性
    print(Cat.type)

    # 强制访问实例私有属性
    print(cat1._Animal__sex)
    # 强制访问类私有属性
    print(Cat._Animal__count)


# 输出
# shell>  miao miao miao
# shell>  I'm a Cat,My name is mimi, male:True

# shell>  True True <class '__main__.Cat'>

# shell>  Cat
# shell>  cat1
# shell>  Cat

# shell>  True
# shell>  2

基础知识点

• 类属性：定义在类内部，使用类访问
• 实例属性：定义在类内部，并通过self或者实例访问
• 开头为两个下划线的属性表示私有属性（如：self.__type），原则上只有类和实例自己能访问，其实外面也能访问，使用：下划线+类名+属性名（如：_Animal__type）这种方式强制访问
• 判断类型使用：type()和isinstance()，isinstance可以判断包括父类在内的类型
• set/get方法：使用@property装饰器，设置属性的set/get方法

class Animal(object):
    @property
    def sex(self):
        return self.__sex

    @sex.setter
    def sex(self, sex):
        if not isinstance(sex, bool):
            raise ValueError('name must be True or False!')
        self.__sex = sex

---

特殊方法

• __init__()
  初始化属性
  子类使用super().__init__函数调用父类构造函数
• __slots__()
  定义允许绑定的属性集合

class Animal(object):
    __slots__ = ('name', 'age', 'type') 

• __str__()与__repr__()
  定制实例的字符串

• __iter__与__next__()
  实现__next__方法的类称为迭代器，实现__iter__方法，其返回一个迭代器，称为可迭代对象，可用于for…in语法（详情见此）

• __getitem__
  实现此方法，即拥有类似list的行为，可通过下标访问，

• __getattr__
  获取类属性的自定义方法，此方法有很多巧妙的用法

class Chain(object):

    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    def __str__(self):
        return self._path

    __repr__ = __str__

# 测试结果
# >>> Chain().status.user.timeline.list
# '/status/user/timeline/list'

• __call__
  实现此方法的类，它的实例是一个可调用对象，可以向函数一样使用此类的一个对象

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

    def __call__(self):
        print('My name is %s.' % self.name)


# >>> s = Student('Michael')
# >>> s()
# My name is Michael.
# >>> callable(s)   # callable()函数判断是否是可调用对象
# True

---

枚举类

from enum import Enum, unique

@unique     # 用来检查重复值
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

if __name__ == '__main__':
    sat = Weekday.Sat
    print(sat)
    print(sat.value)
    print(Weekday(3))

# 输出
# shell>  Weekday.Sat
# shell>  6
# shell>  Weekday.Wed

---

其他特性

• python允许多重继承