面向对象编程中最重要的一个概念也就是类和对象。所以下面来介绍一下类的相关内容
类和对象
类是抽象的模板，比如我们抽象一个学生类，很容易想到学生固有的一些属性，比如名字，年龄等等,创建一个学生类:
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()，我们就可以直接操作一个对象的状态。
最后
面向对象其实有很多知识点可以写，我只是做一个摘要而已，希望自己能坚持下去吧~
