01类和对象：
面向过程和面向对象的编程：
面向过程的编程：函数式编程，C程序等。
面向对象的编程：C++，Java，Pyton 等
类和对象：是面向对象中的两个重要概念
类：是对事物的抽象，比如：汽车模型
对象：是类的一个实例，比如：QQ轿车，大客车
范例说明：
汽车模型可以对汽车的特征和行为进行抽象，然后可以实例化为一台真实的汽车实体出来。
02 Python类定义：
使用class关键字定义一个类，并且类名的首字母要大写；
当程序需要创建的类型不能用简单类型表示时就需要创建类；
类把需要的变量和函数组合在一起，这种包含也称之为“封装”。
Python 类的结构
class类名：
成员变量
成员函数
classTest:
first= 123
second= 456
deff(self):
return‘test’
类的创建：
类的方法中至少有一个参数self
类方法也分为：公有方法和私有方法
私有方法：不能被外部的类和方法调用，私有方法的定义和私有属性的定义都是一样的，在方法前面加上“__”双下线就可以了；
类方法：被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用（是继承的关系）；
静态方法：相当与“全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义静态方法没有“self”语句；
self参数：
用于区分函数和类的方法（必须有一个self）,self参数指向对象本身。
对象的创建：
创建对象的过程称之为实例化；当一个对象被创建后，包含三个方面的特征：对象的句柄，属性和方法。
句柄用于区分不同的对象
对象的属性和方法与类中的成员变量和成员函数对应
if__name___==”__main__”:
myClass1=MyClass()#创建类的一个实例（对象）
Python对象的体系结构
经典对象-内部由属性和方法组成，属性可以是数据类型也可以是函数类型。如属性为函数则该属性就是一个方法。
类的内部方法-Python类当中提供了一些内部方法，方法名油前后连个下划线加字母组成。例如：Python的构造函数__init__.
新型对象-定义新型对象，必须继承object方法class_name(object)新型对象提供了对类方法和静态方法的支持。
类的属性：
类由属性和方法组成，类的属性是对数据的封装，类的方法是对类的行为的封装。类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称
公有属性：所谓公有属性就是在类中和类外调用的属性
私有属性：不能被类以外的函数调用
（可以通过instance.__classname__attribute方式访问，但只用于调试程序，定义方式：以“__”双下划线开始的成员变量就是私有属性，否则是公有属性。）
内置属性：由系统在定义类的时候默认添加的，由前后两个下划线构成__dict__ , __module__
#!/usr/bin/python
#coding:utf8
name = “global”
class Ren(object):
name= “人”
high= “一人高”
wight=”一人重”
__money= “我有时块钱”
defrun (self):
printself.name
print“跑步”
defsay (self):
lie= “我很欣赏你”
printself.__money
printlie
defmoRi(self):
print“世界末日”
mr= classmethod(moRi)
mi= staticmethod(moRi)
if __name__ == ‘__main__’:
zhangsan= Ren()
zhangsan.say()
@classmethod类的装饰器
@statcmethod
练习：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
class Myclass:
var1= “类的属性”
def__init__(self):
self.var1= “对象的属性1”
self.var2= “对象的属性2”
deffunc(self):
print“对象方法”
fs= classmethod(func)
deffunc2(self):
print“对象的方法2”
print Mclass.var1
Myclass.fs()
mys= Myclass()
print mys.var1
mys.vunc()
print Myclass.var1
构造- 析构
内部类：
所谓内部类，就是在类的内部定义的类，主要目的是为了更好的抽象现实世界，
内部类的举例：
汽车是个类，汽车底盘，轮胎也可以抽象为类，将其定义到汽车类中，则形成内部类，更好的描述汽车类，因为底盘，轮胎是汽车的一部分。
一般不赞同使用内部类，会使程序结构复杂，但是理解内部类有助于理解模块的调用。
class Milo():
classTest():
var1=”我是内部类”
内部类的实例化方法：
方法1：直接使用外部类调用内部类
调用格式：
object_name= outclass_name.inclass_name()
outclass_name表示外部类的名称，inclass_name表示内部类的名称，
object_name表示内部类的实例
方法2：先对外部类进行实例化，然后在实例化内部类
调用格式：
out_name= outclass_name()
in_name=out_name.inclass_name()
in_name.method()
out_name()表示外部类的实例，in_name表示内部类的实例
构造函数与析构函数：
构造函数：
用于初始化类的内部状态，Python提供的构造函数是__init__();
__init__()方法是可选的，如果不提供，Python会给出一个默认的__init__方法；
一般对数据的获取需要自定义的get和set方法。
析构函数：
用于释放对象占用的资源，Python提供的析构函数是__del__();
__del__()也是可选的，如果不提供，则Python会在后台提供默认析构函数
如果要显式的调用析构函数，可以使用del关键字，方式如下：del对象名。
def __init___(self,n=”xx”):
sel.name=n
def __del__(self):
p.close()
print‘释放资源！’
垃圾回收机制：
Python采用垃圾回收机制来清理不再使用的对象；Python提供gc模块释放不再使用的对象Python采用“引用计数”的算法方式来处理回收，即：当某个对象在其作用域内不再被其他对象引用的时候，Python就自动清除对象；Pyton的函数collect()可以一次性收集所有待处理的对象(gc.collect())
属性例题：
#!/usr/bin/env python
#coding:utf8
var 4 = “全局变量”
class Milo():
var1= “类属性，公有属性var1”
__var2= “类的私有属性 __var2”
deffun(self):
self.var2= “对象的公有属性var2”
self.var3=”对象的私有属性__var3”
var4= “函数fun的局部变量var4”
printvar4
printself.__var3
defother(self):
printvar4
printself.__var3
zou = Milo()
zou.other()
print “#”*50
方法例子：
#!/usr/bin/python
#coding:utf8
class Milo():
name= “csvt”
deffun1(self):
printself.name
print“我是公有方法”
self.__fun2()
def__fun2(self):
print“我是私有方法”
@classmethod
def classFun(self):
print self.name
print“我是类方法”
classnewfun =classmethod(classfun)
@staticmethod
def staticFun():
print Milo.name
print“我是静态方法”
staticnewfun= staticmethod(staticFun)
zou = Milo()
zou.fun1()
zou.__fun2() #私有方法不能访问。
Milo.fun1() #不可直接访问公有方法。
Milo.name#可以直接访问公有属性
Milo.classnewfun()#可以类直接调用。
Milo.staticfun()#可以直接调用。
类间关系：
当多个类被设计完成时，一般都会有类与类之间的相互关系；
类之间存在继承，组合，依赖等关系；
继承是面向对象的重要特性之一；
继承关系：继承是相对两个类而言的父子关系，子类继承了父类的所有公有属性和方法;继承实现了代码的重用。
使用继承：
继承可以重用已经存在的数据和行为，减少代码的重编写。Python在类名后使用一对括号来表示继承的关系，括号中的类即为父类。
格式：
ClassMyclass(ParentClass)
注意：
如果父类定义了__init__方法，子类必须显示调用父类的__init__方法
（”BaseClass.__init__(self,[args…])”）.
如果子类需要扩展父类的行为，可以添加__init__方法的参数；
范例代码：
#!/usr/bin/env python
#-*-coding:utf-8 -*-
class Parent():
deffun(self):
print“我是父类”
class Myclass (Parent):
deffunc(self):
print“我是子类”
test = Myclass()
test.fun()
test.func()
多重继承，按前后顺序解决冲突问题。
