面向对象编程中最重要的一个概念也就是类和对象。所以下面来介绍一下类的相关内容

类和对象

类是抽象的模板，比如我们抽象一个学生类，很容易想到学生固有的一些属性，比如名字，年龄等等,创建一个学生类:

class Student(object):
    pass

这里的object是表明Student类是从哪个类继承来的，在python中object是所有类的父类（继承的概念下文会提及）

创建实例对象tom：

tom = Student()
//我们可以自由地给类绑定属性：
tom.name = 'XiaoMing'
tom.age = 23

那么既然类具有模板的作用，所以我们可以把一些属性强行绑定给类

class  NewStudent(object):
    def init(self,name,age):
        self.name = name
        self.age = age

这里需要注意一点__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部可以把各种属性绑定到self。有了__init__方法，在创建实例的时候就不能传入空的参数了，必须传入与__init__方法匹配的参数，但是self不需要传，python解释器会自己把实例变量传进去。

我们可以给类添加打印学生信息的方法，把逻辑放在类内部，外部只需要调用即可：

class  NewStudent(object):
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def printInfo(self):
        print('name:%s,age:%s'%(self.__name,self.__age))

john = NewStudent('JOHN',32)
//类外部调用：
john.printInfo()

访问限制

在上面的代码中，我们虽然把属性方法写在了类的内部，实际上，我们从外面还是能够对他进行修改的，python中在属性的名字前面加双下划线就使属性变成了私有，外部不能访问也不可更改。

class  NewStudent(object):
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

如果我们有想要获取想要更改怎么办呢？可以通过get set方法：

class  NewStudent(object):
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def printInfo(self):
        print('name:%s,age:%s'%(self.__name,self.__age))

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self,name):
        self.__name = name

    def set_age(self,age):
        self.__age = age

john.set_name('HAHA')
john.set_age(10)

print(john.get_name())
print(john.get_age())

至于为什么这么折腾呢？写成私有变量的好处就是我允许外部访问或修改，但是我内部是有判断的。

继承和多态

在OOP程序设计中，我们定义一个类的时候，可以从现有的类继承；新的类就称为子类，而被继承的类就是父类，基类或超类。

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

上面的三个类，Animal就是Dog和Cat的父类，那么继承有什么好处呢？

dog = Dog()
cat = Cat()

dog.run()
cat.run()
//Animal is running...
//Animal is running...

从上面的代码可以看出，子类继承了父类的全部方法（功能）;

当然子类也可以拥有自己的方法：

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

    def eat(self):
        print('Animal is eating...')

class Dog(Animal):

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

    def bark(self):
        print('Dog is barking...')

class Cat(Animal):

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

    def jump(self):
        print('Cat is jumping...')

dog = Dog()
cat = Cat()

dog.run()
dog.eat()
dog.bark()

cat.run()
cat.eat()
cat.jump()

继承还有一个好处就是，子类可以对父类的方法进行重写，当子类和父类都有同样的方法时，子类会覆盖父类的方法，这就是继承的另一个好处：多态。

多态其实讲了一个现实生活很常见的现象，那就是狗是动物，猫也是动物，但是动物不是狗，动物也不是猫；继承导致了Dog和Cat类有了两种类型，这是一个很重要的功能

比如我们定义一个方法：

def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())

当我们传入Animal实例就会执行两次run方法

run_twice(Dog())
run_twice(Cat())

当我们传入子类对象的时候,子类对象也会执行两次类方法

获取对象信息

当我们拿到一个对象的引用，如何知道这个对象是什么类型有什么方法？

使用type()

print(type(123) == int)
print(type('123') == str)

判断基本类型可以直接写int，str，但是如果要判断对象是不是函数呢？

import types

def function():
    pass 

print(type(function) == types.FunctionType)
print(type(lambda x: x*x) == types.LambdaType)
print(type((x for x in range(10)))==types.GeneratorType)
print(type(abs)==types.BuiltinFunctionType)

使用isinstance()

a = Animal()
d = Dog()
c = Cat()

print(isinstance(a,Animal))
print(isinstance(d,Animal))
print(isinstance(d,Dog))

使用dir()

dir()返回一个包含字符串的list

dir('123')
//可以获取str对象的所有属性和方法

类似XXX的属性和方法在python中都是有特殊用途的，比如len方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的len()方法，所以，下面的代码是等价的：

len('123')
'123'.__len__()
//运行结果:
//3

淡然仅仅把属性和方法列出来是不够的，还有配合getattr()、setattr()以及hasattr()，我们就可以直接操作一个对象的状态。

最后

面向对象其实有很多知识点可以写，我只是做一个摘要而已，希望自己能坚持下去吧~