python 面向对象编程

所有方法的第一个参数必须是 self，self 表示类是实例本身，类似于 c++ 中的 this 指针。当然我们也可以讲 self 写成其它名字：

class MyClass(object):
    i = 123
    def f(this):#self写成this也是正确的
        return 'hello'

gel = MyClass()
print(gel.i)
print(gel.f())

构造函数

行为基本和 c++ 中的构造函数类似，但当有多个构造函数时，只能调用最后一个构造函数，否则会报错：

#!/usr/bin/python3

class gel(object):
    def __init__(self):
        print("构造函数1")
    def __init__(self, cnt):
        print(cnt)

# a = gel()#如果定义了多个构造函数，则只能调用最后一个，否则会报错
a = gel(1)

注意：一个类中可以定义多个构造方法，但实例化类时只实例化最后的构造方法，即后面的构造方法会覆盖前面的构造方法，并且需要根据最后一个构造方法的形式进行实例化。因此通常一个类中只定义一个构造函数

类的访问权限

在 python 中，类成员变量名如果以 __ 开头，就会编程私有变或私有方法，只能在类内部访问，外部不能访问

继承

在继承中，基类的构造方法（__init__() 方法）不会被自动调用，需要在子类的构造方法中专门调用

在调用基类的方法时需要加上基类的类名前缀，并带上 self 参数变量。区别于在类中调用普通函数时不需要带 self 参数

在 python 中，首先查找对应类型的方法，如果在子类中找不到对应的方法，才到基类中逐个查找

代码：

#!/usr/bin/python3

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

dog = Dog()
dog.run()

cat = Cat()
cat.run()

# 输出：
# Animal is running...
# Animal is running...

注意：派生类中也不能调用基类的私有方法

多态

python 的多态不同于 c++ 中需要通过虚函数来实现。当子类和父类存在相同的方法时，运行代码时总是自动调用对应对象的版本：

#!/usr/bin/python3

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

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

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

dog = Dog()
dog.run()

cat = Cat()
cat.run()

animal = Animal()
animal.run()

# 输出：
# Dog is running...
# Cat is running...
# Animal is running...

多重继承

多重继承的类定义：

class DerivedClassName(Base1, Base2, Base3):
　　pass

需要注意圆括号中父类的顺序，若父类中有相同的方法名，在子类使用时未指定，python 会从左到有搜索。

调用对应方法时，若方法在子类中未找到，则从左到右查找父类中是否包含该方法

代码：

#!/usr/bin/python3

class Animal(object):
    pass

#大类
class Mammal(Animal):
    pass

class Bird(Animal):
    pass


class Runnable(object):
    def run(self):
        print('running...')

class Flyable(object):
    def fly(self):
        print('Flying...')

class Dog(Mammal, Runnable):
    pass

class Bat(Mammal, Flyable):
    pass

类的专有方法

形如 __xxx__ 变量或函数名在 python 中是有特殊用途的

除了前面的构造函数 __init__ 外还有：

__str__ 和 __repr__

类似于c++中重载<<运算符，将类对象按给定的格式转化成字符串

class Test(object):
    def __init__(self, value='hello, world!'):
        self.data = value

>>> t = Test()
>>> t
<__main__.Test at 0x7fa91c307190>
>>> print t
<__main__.Test object at 0x7fa91c307190>

# 看到了么？上面打印类对象并不是很友好，显示的是对象的内存地址
# 下面我们重构下该类的__repr__以及__str__，看看它们俩有啥区别

# 重构__repr__
class TestRepr(Test):
    def __repr__(self):
        return 'TestRepr(%s)' % self.data

>>> tr = TestRepr()
>>> tr
TestRepr(hello, world!)
>>> print tr
TestRepr(hello, world!)

# 重构__repr__方法后，不管直接输出对象还是通过print打印的信息都按我们__repr__方法中定义的格式进行显示了

# 重构__str__
calss TestStr(Test):
    def __str__(self):
        return '[Value: %s]' % self.data

>>> ts = TestStr()
>>> ts
<__main__.TestStr at 0x7fa91c314e50>
>>> print ts
[Value: hello, world!]

# 你会发现，直接输出对象ts时并没有按我们__str__方法中定义的格式进行输出，而用print输出的信息却改变了

这部分代码摘自：https://blog.csdn.net/luckytanggu/article/details/53649156

通常__str__() 和 __repr__() 的代码是一样的，所以可以写成：

#!/usr/bin/python3

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

    def __str__(self):
        return '学生名称：%s' % self.name

    __repr__ = __str__

st = Student('xiao004')
print(st)
# 输出:
# 学生名称：xiao004

__iter__

如果想将一个类用于 for...int 循环，类似于 list 或 tuple 一样，就必须实现一个 __iter__() 方法。该方法返回一个迭代对象，python 的 for 循环会不断调用迭代对象的 __next__() 方法，获得循环的下一个值，知道遇到 StopIteration 错误时退出循环：

#!/usr/bin/python3

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1

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

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > 100:
            raise StopIteration();#引发一个异常
        return self.a

for n in Fib():
    print(n)
# 输出：
# 1
# 1
# 2
# 3
# 5
# 8
# 13
# 21
# 34
# 55
# 89

__getitem__

上面定义的 Fib 虽然能作用于 for 循环，和 list 有点像，但不能和 list 一样用下标取元素。要像 list 一样按照下标取出元素，需要实现 __getitem__() 方法：

#!/usr/bin/python3

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1

    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

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

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > 100:
            raise StopIteration();#引发一个异常
        return self.a

fib = Fib()
print(fib[3])#3
# for i in fib:
#     print(i)

__getattr__

正常情况下，调用类的方法或属性时，如果类的方法或属性不存在就会报错。当实现了 __getattr__() 方法会动态返回一个属性.：

class Studet(object):
    def __init__(self):
        self.name = 'xiao004'

    def __getattr__(self, attr):
        if attr == 'score':
            return 95

st = Studet()
print(st.score)#st并没有score属性，动态返回一个属性
# 输出：
# 95

当调用不存在的属性 score 时，python 解释器会调用 __getattr__(self，‘score’) 尝试获得属性。

注意：只有在没有找到属性的情况下才调用__getattr__。此外，如果我们调用一个不存在且 __getattr__ 中也没处理的属性，仍然会报错

__call__

Python中的函数是一级对象。这意味着Python中的函数的引用可以作为输入传递到其他的函数/方法中，并在其中被执行。 
而Python中类的实例（对象）可以被当做函数对待。也就是说，我们可以将它们作为输入传递到其他的函数/方法中并调用他们，正如我们调用一个正常的函数那样。而类中__call__()函数的意义正在于此。为了将一个类实例当做函数调用，我们需要在类中实现__call__()方法。也就是我们要在类中实现如下方法：def __call__(self, *args)。这个方法接受一定数量的变量作为输入。 
假设x是X类的一个实例。那么调用x.__call__(1,2)等同于调用x(1,2)。这个实例本身在这里相当于一个函数。

这段描述摘自：https://blog.csdn.net/yaokai_assultmaster/article/details/70256621

即：实现了 __call__() 函数后能将实例本身当成一个函数使用

代码：

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

    def __call__(self):
        print('名称：%s' % self.name)

stu = Student('xiao004')
stu()#实现了__call__()函数后能将实例本身当成一个函数使用
# 输出：
# 名称：xiao004

问题

双下划线开头的实例变量一定不能从外部访问么？

答：不是。不能从类外直接访问双下划线开头的变量是因为 python 解释器对外改变了双下划线开头的变量的名称

如：

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

    def info(self):
        print('学生：%s; 分是: %s' % (self.__name, self.__score))

stu = Student('xiao004', 100)
# print(stu.__score)#错误，__score是私有变量
print(stu._Student__score)

在此列中不能直接访问 __score 是因为 python 解释器对外把 __score 变量改成了 _Student__score，所以我们能在类外用过 _Student__score 访问 __score 变量