python面向对象

Python面向对象编程

类

对于Python2.7

class xxxx(object):
    pass

对于Python3.x

class xxx ():
    pass

访问限制

1. Python没有访问限制相关的强类型语法，一大半靠自觉。

2. __xxx : 前面加了双下划线的代表私有类型变量，类外不能访问。

   其实Python把__xxx打包成了 如下格式，还是可以访问，所以说靠自觉

   _类名__xxx
   a._Student__name

3. 下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

继承和多态

看下面，一个动物类，狗继承了它，猫继承了它，乌龟继承了它。

注意：子类会覆盖父类。

根据前两条，产生了多态，例如下面的run()函数。（还不理解的话把dog写成int , cat写成float ,…….）

class Animal():
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')

class Cat(Animal):
    def run(self):
        print('Cat is running...')

class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')

def run(animal):
    animal.run()

run(Dog())
run(Cat())
run(Tortoise())

方法

就是类里面定义的函数

类属性和实例属性

类属性：类的所有实例都可以访问到

class Pencil():
    # length就是类属性
    length = 22
    # self.material就是实例属性
    def __init__(self, material):
        self.material = material
    pass

__slot__

这个类中，规定只能有哪些属性，（调用其他属性时候报错）作用域只有此类，子类管不到。

@property

装饰器，把方法装饰成属性。写出更加简洁的代码。

class Student():
    """ hello """
    __slots__ = ("__score")

    def __init__(self):
        self.__score = 99

    @property
    def score(self):
        return self.__score

    @score.setter
    def score(self,value):
        if isinstance(value,int):
            self.__score = value
        else:
            print("error@")
            return

a = Student()
a.score = 401
print(a.score)

多重继承

集成许多类，父类之间用逗号隔开

定制类

__len__

类可以使用len()函数

class Student():
    """ test """
    def __init__(self,*args):
        self.names = args

    def __len__(self):
        return len(self.names)

__iter__ __next__

类拥有next()方法

class Fib(object):
    """ iter test """

    def __init__(self):
        self.a, self.b = 0, 1  # 初始化两个计数器a，b

    def __iter__(self):
        return self  # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b  # 计算下一个值
        if self.a > 100000:  # 退出循环的条件
            raise StopIteration()
        return self.a  # 返回下一个值

__call__

类本身可调用

class Student():
    """ __call__ test """
    def __init__(self,name):
        self.name = name
    def __call__(self):
        print("My name is %s" %self.name)

ss = Student('huajian')
ss()

__getattr__ __str__

前者用来处理类中 没有定义的 属性 ，，后者用来修改显示效果。

1 . 把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段（这里只响应age）

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

2 . 二者结合处理网站的API ， 不用一个个定义一大堆。

class Chain():
    """ __getattr__ """

    def __init__(self, path="www.baidu.com"):
        self.path = path

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

    def __str__(self):
        return self.path

    __repr__ = __str__


a = Chain()
print(a.user.qwe)
>>> www.baidu.com/user/qwe   这是输出结果

其他__xx__

还有好多其他，不常用，不写了。

枚举类

常常用来设置真真的常量，因为python中没有const，#define之类的东西。

一般从Enum派生出自定义类：

from enum import Enum, unique


@unique装饰器可以帮助我们检查，保证没有重复值
@unique
class Weekday(Enum):
    Sun = 0  # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6


print(Weekday.Fri.value)