一，类和类的定义：
*面向对象的基础（实现类的过程当中实际上就是对现实事物的进一步抽象）
*一种类型（类的类型）
*类的实例称之为对象（例如 ‘瓶子’是一类型的东西， ‘桌子上的那个瓶子’，比较具体 是一个对象）
*一种用户自定义的类型
*类里面有很多自定义的属性和方法（写代码的时候没有必要把所有的属性方法列出来，只需要列出有用到的就行）
例子：Cat类：
属性(变量，属性的名称)：名称 种类 皮毛 猫龄
行为（方法 函数）：爱吃鱼 捉老鼠 喵喵叫
二，类的属性和方法：
1，类的特殊方法：
-构造函数：
*是一种特殊类型的方法(函数),他的类是实例化对象时被调用，构造函数通常用于初始化(赋值)给实例变量
*构造函数还验证有足够的资源来使对象执行任何启动任务
*构造函数是以双下划线(__)开头的函数类型，构造函数的名称是：__init__()
*创建对象时，如果需要，构造函数可接受传参，当创建没有构造函数的类时，Python会自动创建不执行任何操作的默认构造函数
*参数就是对象的属性，比如小王是一个类的话，那么他的名字就是他的一个属性，小王就是属性的值；
语法：
def __init__(self,name,*args,**kwargs):
self.name = name
pass说明：self代表当前类的实例对象， self.name表示将name绑定到实例上，即该类了有实例属性name， 等号右边的name表示__init__()中的参数name。在访问该属性时可以使用创建的实例对象调用
-析构函数：
*一般不用写，默认就会存在，Python解释器处理内存，不去要是哟个类的时候就自动收回内存
语法：
def __del__(self):
pass
-定义一个类：使用 class 语句来创建一个新类
例如 定义一个Cat的类：
说明 ：class 名称（在里面尽量写入object，不仅与python2更有兼容性，即使里面没有东西也可以执行object，写不写一样，但是object换成其他类就是指这个类继承那个类）
class Cat(object):
"""猫科动物类"""
def __init__(self,name):
self.name = name
pass
def eat(self):
pass2，其他类的特殊方法：
-文档信息：__doc__
-查看模块信息：__module__
-自定义类属性：tag
-自定义的类方法：catch
*进入Python交互式环境，查dir(Cat) 会发现里面还有很多特殊的属性，如下图
查看文档信息 Cat.__doc__ 如下图，可看到代码中的文档注释
Cat.__mudule__ 返回模块的名称
help(Cat)
Cat.__class__ 类的实例一个指向
Cat.__bases__ 返回一个元组显示所继承的类
调整代码后 查看bases继承自哪里：
class Cat(object):
"""猫科动物类"""
def __init__(self,name):
self.name = name
pass
def eat(self):
pass
class Tiger(Cat):
pass重新进入环境：
三，类的实例：
class Cat(object):
# 类的属性，继承这个类的都可以使用
tag = "我是家猫"
def __init__(self,name,salary):
self.name = name
self.salary = salary
def set_salary(self,salary):
"""
改变猫的价钱
:param salary: init价钱
:return: 更改后的价钱
"""
self.salary = salary
return self.salary
def show_catInfo(self):
"""
显示猫的信息
:return:
"""
rest = 'name:{0},salary:{1}元'.format(self.name,self.salary)
print(rest)
return rest
def eat(self):
"""吃"""
print('猫喜欢吃鱼')
def catch(self):
"""捉老鼠"""
print('猫能捉老鼠')
cat1 = Cat('加菲猫','10000')#创建类的对象
cat1.set_salary('20000') #改变加菲猫的价钱
cat1.show_catInfo()
cat1.eat()
cat1.catch()
#内置类属性调用
print('_______________________________________________')
print("Cat.__doc__:",Cat.__doc__)
print("Cat.__name__:", Cat.__name__)
print("Cat.__module__:", Cat.__module__)
print("Cat.__bases__:", Cat.__bases__)
print("Cat.__dict__:", Cat.__dict__)运行结果：
name:加菲猫,salary:20000元
猫喜欢吃鱼
猫能捉老鼠
_______________________________________________
Cat.__doc__: None
Cat.__name__: Cat
Cat.__module__: __main__
Cat.__bases__: (,)
Cat.__dict__: {'__module__': '__main__', 'tag': '我是家猫', '__init__': , 'set_salary': , 'show_catInfo': , 'eat': , 'catch': , '__dict__': , '__weakref__': , '__doc__': None}类的实例判断 ：isinstance()
print(isinstance(cat1,Cat)) #返回True 是Cat的实例
四，类的继承
实现代码的重用方法之一是通过继承机制
*通过继承创建的新类成为子类或派生类，被继承的类称为基类或者父类
1，继承的特点：
*如果在子类中需要父类的构造方法，就需显式的调用父类的构造方法，或者不重写父类的构造方法
*在调用基类的方法时，需要加上基类的类名前缀，且需要带上self 参数变量 。区别在于类中调用普通函数时并不需要带上self 参数。
*Python总是首先查找对应类型的方法，现在本类中查找调用的方法，找不到才去基类中找
2，子类继承父类的构造说明:
*子类需要自动调用父类的方法：子类不重写__init__()方法，实例化子类后，会自动调用父类的 __init__()方法
class Father(object):
def __init__(self,name):
self.name = name
print('name:{0}'.format(self.name))
def getName(self):
return 'Father:' + self.name
class Son(Father):
def getName(self):
return 'Son:' + self.name
if __name__ == '__main__':
son = Son('王')
print(son.getName())运行结果：
*子类不需要自动调用父类的方法：子类重写__init__()方法，实例化子类后，将不会自动调用父类的 __init__()方法
class Father(object):
def __init__(self,name):
self.name = name
print('name:{0}'.format(self.name))
def getName(self):
return '小兰的Father:' + self.name
class Son(Father):
def __init__(self,name):
print('老王的孩子')
self.name = name
def getName(self):
return 'Son:'+ self.name
if __name__ == '__main__':
son = Son('王')
print(son.getName())运行结果：
*子类重写__init__()方法 又需要调用父类 方法：使用super关键字，语法：super(子类，self).__init__(参数1，参数2....)
class Father(object):
def __init__(self,name):
self.name = name
print('name:{0}'.format(self.name))
def getName(self):
return '小兰的Father:' + self.name
class Son(Father):
def __init__(self,name):
super(Son, self).__init__(name)
self.name = name
def getName(self):
return 'Son:'+ self.name
if __name__ == '__main__':
son = Son('王')
print(son.getName())运行结果：
是否是子类的判断：issubclass()
print(issubclass(Son,Father))
